added vrpmdv-rtservice, vrpmdv-mon-datafile,

vrpmdv-monitoring-controler, vrpmdv-mon-tty

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "files.associations": {
+        "rpmsg.h": "c",
+        "types.h": "c",
+        "ioctl.h": "c",
+        "wait.h": "c"
+    }
+}

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/.~lock.Create-Kernel-Driver.odt#

@@ -0,0 +1 @@
+,markus,U2204VM,02.05.2024 10:15,file:///home/markus/.config/libreoffice/4;

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/files/75-mon-datafile.rules

@@ -0,0 +1 @@
+SUBSYSTEM=="misc", KERNEL=="mon-datafile", GROUP="dialout", MODE="0666"

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/files/Makefile

@@ -0,0 +1,26 @@
+# Makefile for VRPMDV Monitoring Datafile
+obj-m := vrpmdv-mon-datafile.o
+
+
+SRC := $(shell pwd)
+
+all:
+	$(MAKE) -C $(KERNEL_SRC) M=$(SRC)
+
+modules_install:
+	$(MAKE) -C $(KERNEL_SRC) M=$(SRC) modules_install
+
+clean:
+	rm -f *.o *~ core .depend .*.cmd *.ko *.mod.c
+	rm -f Module.markers Module.symvers modules.order
+	rm -rf .tmp_versions Modules.symvers
+
+# obj-m = vrpmdv-monitoring-controler.o
+
+# KVERSION = $(shell uname -r)
+
+# all:
+# 	make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
+
+# clean:
+# 	make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/files/lock.csave

@@ -0,0 +1,116 @@
+include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <thread>
+ 
+std::mutex m;
+std::condition_variable cv;
+std::string data;
+bool ready = false;
+bool processed = false;
+ 
+void worker_thread()
+{
+    // wait until main() sends data
+    std::unique_lock lk(m);
+    cv.wait(lk, []{ return ready; });
+ 
+    // after the wait, we own the lock
+    std::cout << "Worker thread is processing data\n";
+    data += " after processing";
+ 
+    // send data back to main()
+    processed = true;
+    std::cout << "Worker thread signals data processing completed\n";
+ 
+    // manual unlocking is done before notifying, to avoid waking up
+    // the waiting thread only to block again (see notify_one for details)
+    lk.unlock();
+    cv.notify_one();
+}
+ 
+int main()
+{
+    std::thread worker(worker_thread);
+ 
+    data = "Example data";
+    // send data to the worker thread
+    {
+        std::lock_guard lk(m);
+        ready = true;
+        std::cout << "main() signals data ready for processing\n";
+    }
+    cv.notify_one();
+ 
+    // wait for the worker
+    {
+        std::unique_lock lk(m);
+        cv.wait(lk, []{ return processed; });
+    }
+    std::cout << "Back in main(), data = " << data << '\n';
+ 
+    worker.join();
+}
+
+--------------------
+
+// waiting for timeout after 5 seconds
+std::chrono::seconds timeoutPeriod = 5;
+auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+std::unique_lock<std::mutex> uLock(myDataMutex);
+while(!DataAreReadyForProcessing())
+{
+    if (myCondVar.wait_until(uLock, timePoint) //<##
+        == std::cv_status::timeout)
+    {
+        // data conditions where not fulfilled within
+        // the time period; e.g. do some error handling
+        break;
+    }
+}
+
+--
+
+if (myCondVar.wait_for(uLock, timeoutPeriod,
+    DataAreReadyForProcessing))
+{
+    // data conditions where fulfilled
+    // regular processing
+}
+else // timeout occured, conditions are not fulfilled
+{
+    // e.g. do some error handling
+}
+
+
+
+
+
+
+-------------
+
+
+static int rpmsg_sample_probe(struct rpmsg_device *rpdev)
+{
+
+	int ret;
+	struct instance_data *idata;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+					rpdev->src, rpdev->dst);
+
+	idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	if (!idata)
+		return -ENOMEM;
+
+	dev_set_drvdata(&rpdev->dev, idata);
+
+	/* send a message to our remote processor */
+	ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	if (ret) {
+		dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return 0;

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/files/vrpmdv-mon-datafile.c

@@ -0,0 +1,720 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) STMicroelectronics 2019 - All Rights Reserved
+ * Author: Jean-Philippe Romain <jean-philippe.romain@st.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+#include <linux/types.h>
+
+#define RPMSG_SDB_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "vrpmdv-mon-datafile";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+struct vRCMDeviceData {
+	uint32_t  packageNo;  //current package Number
+	uint32_t  packageCount; //complete package Number
+	uint32_t  dataQuantity;	//number of uint32_t in data
+	uint32_t  data[]; //the data
+};
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_info("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+	//__u32* data = (__u32*) rxbuf_str;
+	struct vRCMDeviceData* pdata = (struct vRCMDeviceData*) rxbuf_str;
+
+
+	//pr_info("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+	pr_info("rpmsg_sdb(%s): packageno:%d\n", __func__, pdata->packageNo);
+	pr_info("rpmsg_sdb(%s): packageCount:%d\n", __func__, pdata->packageCount);
+	pr_info("rpmsg_sdb(%s): dataquantity:%d\n", __func__, pdata->dataQuantity);	
+	pr_info("rpmsg_sdb(%s): data:%d\n", __func__, (pdata->data)[0]);
+	// pr_info("rpmsg_sdb(%s): rxbuf_str:%d\n", __func__, data[0]);
+	// pr_info("rpmsg_sdb(%s): rxbuf_str:%d\n", __func__, data[1]);
+	// pr_info("rpmsg_sdb(%s): rxbuf_str:%d\n", __func__, data[2]);
+	
+
+
+	/* Get first part containing the buffer id */
+// 	sub_str = strsep(&rxbuf_str, delimiter);
+
+// //	pr_info("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+// 	/* Save Buffer id and size: template BxLyyyyyyyy*/
+// 	ret = kstrtol(&sub_str[1], 10, &bufid);
+// 	if (ret < 0) {
+// //		pr_info("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+// 		goto out;
+// 	}
+
+// 	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+// 	if (ret < 0) {
+// //		pr_info("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+// 		goto out;
+// 	}
+
+// 	*size = (size_t)bsize;
+// 	*buffer_id = (int)bufid;
+
+// out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	pr_info("rpmsg_sdb(%s): start rpmsg_sdb_send_buf_info\n", __func__);
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_mtu(_rpdev->ept);
+
+	pr_info("rpmsg_sdb(%s): checked msg site:%d\n", __func__, msg_size);
+	if (msg_size < 0)
+		return msg_size;
+
+	pr_info("rpmsg_sdb(%s): Call rpmsg_sdb_format_txbuf_string\n",	__func__);
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		pr_info("rpmsg_sdb(%s): send a message to our remote processor\n", __func__);		
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			pr_info("rpmsg_sdb(%s): error by send a message to our remote processor\n", __func__);					
+			return ret;
+		}
+		else {
+			pr_info("rpmsg_sdb(%s): send succesfully a message to our remote processor\n", __func__);
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	pr_info("rpmsg_sdb(%s): start rpmsg_sdb_mmap\n", __func__);
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	pr_info("rpmsg_sdb(%s): start rpmsg_sdb_mmap - coherent_dma_mask\n", __func__);
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		pr_info("rpmsg_sdb(%s): start rpmsg_sdb_mmap - bufferlist not empty\n", __func__);		
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+
+		if (!_buffer->vaddr) {
+			pr_info("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_info("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot)) {
+
+			pr_info("rpmsg_sdb(%s): remap_pfn_range could not be done\n");
+			return -EAGAIN;
+		}
+
+
+		_buffer->uaddr = (void *)vma->vm_start;
+		pr_info("rpmsg_sdb(%s): _buffer->uaddr = %p\n",	__func__, _buffer->uaddr);
+
+		/* Send information to remote proc */
+		pr_info("rpmsg_sdb(%s): Send information to remote proc\n",	__func__);
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		pr_debug("rpmsg_sdb(%s): No existing buffer entry exist in the list !!!\n", __func__);				
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	pr_debug("rpmsg_sdb(%s): Init bufferlist", __func__);
+	pr_info("rpmsg_sdb(%s): start Init bufferlist", __func__);		
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+	pr_info("rpmsg_sdb(%s): success Init bufferlist", __func__);			
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	mutex_lock(&_rpmsg_sdb->mutex);
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_info("rpmsg_sdb(%s): Free the CMA allocation 3", __func__);
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,	pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+	mutex_unlock(&_rpmsg_sdb->mutex);
+	pr_info("rpmsg_sdb(%s): Free the CMA allocation 4 - done", __func__);
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		pr_info("mon-datafile: set EFD\n");		
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				// pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				pr_info("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");		
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			// pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			pr_info("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");		
+
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+		
+		pr_info("rpmsg_sdb(SUCCES): RPMSG_SDB_IOCTL_SET_EFD \n");		
+		
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		pr_info("mon-datafile: get datasize\n");
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	//pr_info("mon-datafile: receive msg from Copro: %s, len:%d\n", __func__, len);
+
+	// struct rpmsg_sdb_t {
+	// 	struct mutex	mutex; /* mutex to protect the ioctls */
+	// 	struct miscdevice mdev; /* misc device ref */
+	// 	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	// 	struct list_head buffer_list; /* buffer instances list */
+	// };
+
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	// ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    
+	// if (ret < 0)
+	// 	goto out;
+
+	// if (buffer_id > LastBufferId) {
+	// 	ret = -EINVAL;
+	// 	goto out;
+	// }
+
+	struct vRCMDeviceData* pdata = (struct vRCMDeviceData*) rpmsg_RxBuf;
+
+
+	//pr_info("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+	// pr_info("rpmsg_sdb(%s): packageno:%d\n", __func__, pdata->packageNo);
+	// pr_info("rpmsg_sdb(%s): packageCount:%d\n", __func__, pdata->packageCount);
+	// pr_info("rpmsg_sdb(%s): dataquantity:%d\n", __func__, pdata->dataQuantity);	
+	// pr_info("rpmsg_sdb(%s): data:%d\n", __func__, (pdata->data)[0]);
+
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+	if (drv == NULL) {
+		dev_err(rpmsg_sdb_dev, "(%s) no driver found\n", __func__);		
+		return -EINVAL;		
+	}
+    
+	//copy data to structure
+	//1. get buffer
+
+	// struct vRCMDeviceData* pdata = (struct vRCMDeviceData*) kmalloc(len+1, GFP_KERNEL);
+	// memcpy(pdata, data, len);
+
+	// if (ret < 0)
+	// 	goto out;
+
+	// if (buffer_id > LastBufferId) {
+	// 	ret = -EINVAL;
+	// 	goto out;
+	// }
+
+
+/** 
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+*/
+	/* Signal to User space application */
+	mutex_lock(&drv->mutex);
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+
+
+		/**
+		 * struct vRCMDeviceData {
+				uint32_t  packageNo;  //current package Number
+				uint32_t  packageCount; //complete package Number
+				uint32_t  dataQuantity;	//number of uint32_t in data
+				uint32_t  data[]; //the data
+			};
+		 */
+		//copy data to buffer
+
+
+	// struct sdb_buf_t {
+	// 	int index; /* index of buffer */
+	// 	size_t size; /* buffer size */
+	// 	size_t writing_size; /* size of data written by copro */
+	// 	dma_addr_t paddr; /* physical address*/
+	// 	void *vaddr; /* virtual address */
+	// 	void *uaddr; /* mapped address for userland */
+	// 	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	// 	struct list_head buflist; /* reference in the buffers list */
+	// };
+
+		//get the buffer as array of struct vRCMDeviceData
+		struct vRCMDeviceData* vrBuff = (struct vRCMDeviceData*) (datastructureptr->vaddr);
+		struct vRCMDeviceData* startAdress =  &(vrBuff[pdata->packageNo]);
+		// pr_info("rpmsg_sdb(%s): startAdress:%d\n", __func__, startAdress);
+
+		if (virt_addr_valid(startAdress)) {
+			if (pdata->packageNo == 1) {
+				//reset writing size
+				datastructureptr->writing_size = 0;	
+			}
+			// pr_info("rpmsg_sdb(%s): startAdress:%d is valid\n", __func__, startAdress);
+			datastructureptr->writing_size = datastructureptr->writing_size + len;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				pr_info("(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			memcpy(startAdress, rpmsg_RxBuf, len);		
+		}
+		else {
+			pr_info("rpmsg_sdb(%s): startAdress[%d]:%p is invalid!!\n", __func__, startAdress);						
+		}
+
+
+		// if (datastructureptr->index == buffer_id) {
+		// 	datastructureptr->writing_size = buffer_size;
+
+		// 	if (datastructureptr->writing_size > datastructureptr->size) {
+		// 		dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+		// 		ret = -EINVAL;
+		// 		goto out;
+		// 	}
+
+		if ((pdata != NULL) && (pdata->packageNo == pdata->packageCount)) {
+			pr_info("rpmsg_sdb(%s): signal bufferfull!\n", __func__);									
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+
+		}
+
+	}
+	mutex_unlock(&drv->mutex);
+
+	/* Signal to User space application */
+/** list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+	}
+*/
+
+out:
+	kfree(rpmsg_RxBuf);
+	//kfree(pdata);
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+	
+	pr_info("mon-datafile: registering started\n");
+	
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "mon-datafile";//"rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	pr_info("mon-datafile: Set Driver data\n");
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		pr_info("mon-datafile: Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	//pr_info("rpmsg_sdb: Failed to register device\n");
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+	pr_info("rpmsg_sdb(%s): remove misc device %s !\n", __func__, drv->mdev.name);									
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "vrpmdv-mon-datafile" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+//static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+static struct rpmsg_driver vrpmdv_monitoring_data = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+module_rpmsg_driver(vrpmdv_monitoring_data);
+
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Markus Lehr <markus@malehr.de>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/kernel-module-vrpmdv-monitoring-driver.bb

@@ -0,0 +1,16 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/netlink-save.c.save

@@ -0,0 +1,541 @@
+/* Copyright 2021 Philipp Schuster
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of 
+ * this software and associated documentation files (the "Software"), to deal in the 
+ * Software without restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies
+ * or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "gnl_foobar_xmpl" which shows you the basics of using
+ * Generic Netlink in the kernel. It registers a Netlink family called "gnl_foobar_xmpl". See
+ * "gnl_foobar_xmpl_prop.h" for common properties of the family. "Generic Netlink" offers us a lot of
+ * convenient functions to register new/custom Netlink families on the fly during runtime. We use this
+ * functionality here. It implements simple IPC between Userland and Kernel (Kernel responds to userland).
+ *
+ * Check "gnl_foobar_xmpl_prop.h" for common properties of the family first, afterwards follow the code here.
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+#include "gnl_foobar_xmpl_prop.h"
+
+// Module/Driver description.
+// You can see this for example when executing `$ modinfo ./gnl_foobar_xmpl.ko` (after build).
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Philipp Schuster <phip1611@gmail.com>");
+MODULE_DESCRIPTION(
+        "Linux driver that registers the custom Netlink family "
+        "\"" FAMILY_NAME "\" via Generic Netlink and responds to echo messages "
+                         "according to the properties specified in \"gnl_foobar_xmpl_prop.h\"."
+);
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+/**
+ * Data structure required for our .dumpit callback handler to
+ * know about the progress of an ongoing dump.
+ * See the dumpit callback handler how it is used.
+ */
+struct {
+    // from <linux/mutex.h>
+    /**
+     * Only one process is allowed per dump process. We need a lock for that.
+     */
+    struct mutex mtx;
+    /**
+     * Number that describes how many packets we need to send until we are done
+     * during an ongoing dumpit process. 0 = done.
+     */
+    int unsigned runs_to_go;
+    /**
+     * Number that describes how many packets per dump are sent in total.
+     * Constant per dump.
+     */
+    int unsigned total_runs;
+} dumpit_cb_progress_data;
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_FOOBAR_OPS_LEN (GNL_FOOBAR_XMPL_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_foobar_xmpl_ops[GNL_FOOBAR_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_FOOBAR_XMPL_C_ECHO_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_echo_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_foobar_xmpl_policy[GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_FOOBAR_XMPL_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_FOOBAR_XMPL_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_foobar_xmpl_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_foobar_xmpl_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_FOOBAR_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_foobar_xmpl_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_ECHO` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_FOOBAR_XMPL_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_FOOBAR_XMPL_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+
+    // Send a message back
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+                           // According to my findings: this is not used for routing
+                           // This can be used in an application specific way to target
+                           // different endpoints within the same user application
+                           // but general rule: just put sender port id here
+                           info->snd_portid, // sending port (not process) id: int
+                           info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags for Netlink header: int; application specific and not mandatory
+                           // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG
+    );
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_FOOBAR_XMPL_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_FOOBAR_XMPL_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/**
+ * ".dumpit"-callback function if a Generic Netlink with command ECHO_MSG and flag `NLM_F_DUMP` is received.
+ * Please look into the comments where this is used as ".dumpit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".dumpit" callbacks.
+ *
+ * A dump must be understand of "give me all data of a given entity"
+ * rather than a "dump of the netlink message itself" for debugging etc!
+ *
+ * This handler requires `gnl_cb_echo_dumpit_before` to run before a dump and `gnl_cb_echo_dumpit_after` after a dump.
+ *
+ * For the sake of simplicity, we use the ECHO_MSG command for the dump. In fact, we don't expect a
+ * MSG-Attribute here, unlike the regular ECHO_MSG handler. We reply with a dump of
+ * "all messages that we got" (application specific, hard coded in this example).
+*/
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb) {
+    void *msg_head;
+    int ret;
+    static const char HELLO_FROM_DUMPIT_MSG[] = "You set the flag NLM_F_DUMP; this message is "
+                                                "brought to you by .dumpit callback :)";
+    pr_info("Called %s()\n", __func__);
+
+    if (dumpit_cb_progress_data.runs_to_go == 0) {
+        pr_info("no more data to send in dumpit cb\n");
+        // mark that dump is done;
+        return 0;
+    } else {
+        dumpit_cb_progress_data.runs_to_go--;
+        pr_info("%s: %d more runs to do\n", __func__, dumpit_cb_progress_data.runs_to_go);
+    }
+
+    msg_head = genlmsg_put(pre_allocated_skb, // buffer for netlink message: struct sk_buff *
+            // According to my findings: this is not used for routing
+            // This can be used in an application specific way to target
+            // different endpoints within the same user application
+            // but general rule: just put sender port id here
+                           cb->nlh->nlmsg_pid, // sending port (not process) id: int
+            // sequence number: int (might be used by receiver, but not mandatory)
+            // sequence 0, 1, 2...
+                           dumpit_cb_progress_data.total_runs - dumpit_cb_progress_data.runs_to_go - 1,
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags: int (for netlink header); we don't check them in the userland; application specific
+            // this way we can trigger a specific command/callback on the receiving side or imply
+            // on which type of command we are currently answering; this is application specific
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG // cmd: u8 (for generic netlink header);
+    );
+    if (msg_head == NULL) {
+        pr_info("An error occurred in %s(): genlmsg_put() failed\n", __func__);
+        return -ENOMEM;
+    }
+    ret = nla_put_string(
+            pre_allocated_skb,
+            GNL_FOOBAR_XMPL_A_MSG,
+            HELLO_FROM_DUMPIT_MSG
+    );
+    if (ret < 0) {
+        pr_info("An error occurred in %s():\n", __func__);
+        return ret;
+    }
+    genlmsg_end(pre_allocated_skb, msg_head);
+
+    // return the length of data we wrote into the pre-allocated buffer
+    return pre_allocated_skb->len;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before(struct netlink_callback *cb) {
+    int ret;
+    static int unsigned const dump_runs = 3;
+    pr_info("%s: dump started. acquire lock. initialize dump runs_to_go (number of receives userland can make) to %d runs\n", __func__, dump_runs);
+    // Lock the mutex like mutex_lock(), and return 0 if the mutex has been acquired or sleep until the mutex becomes available
+    // If a signal arrives while waiting for the lock then this function returns -EINTR.
+    ret = mutex_lock_interruptible(&dumpit_cb_progress_data.mtx);
+    if (ret != 0) {
+        pr_err("Failed to get lock!\n");
+        return ret;
+    }
+    dumpit_cb_progress_data.total_runs = dump_runs;
+    dumpit_cb_progress_data.runs_to_go = dump_runs;
+    return 0;
+
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb) {
+    pr_info("%s: dump done. release lock\n", __func__);
+    mutex_unlock(&dumpit_cb_progress_data.mtx);
+    return 0;
+}
+
+/**
+ * Module/driver initializer. Called on module load/insertion.
+ *
+ * @return success (0) or error code.
+ */
+static int __init gnl_foobar_xmpl_module_init(void) {
+    int rc;
+    pr_info("Generic Netlink Example Module inserted.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_foobar_xmpl_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_init(&dumpit_cb_progress_data.mtx);
+
+    return 0;
+}
+
+/**
+ * Module/driver uninitializer. Called on module unload/removal.
+ *
+ * @return success (0) or error code.
+ */
+static void __exit gnl_foobar_xmpl_module_exit(void) {
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&dumpit_cb_progress_data.mtx);
+}
+
+module_init(gnl_foobar_xmpl_module_init);
+module_exit(gnl_foobar_xmpl_module_exit);

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/rpmsg_sdb.csva

@@ -0,0 +1,536 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) STMicroelectronics 2019 - All Rights Reserved
+ * Author: Jean-Philippe Romain <jean-philippe.romain@st.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+
+#define RPMSG_SDB_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "stm32-rpmsg-sdb";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_debug("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+
+	pr_debug("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+
+	/* Get first part containing the buffer id */
+	sub_str = strsep(&rxbuf_str, delimiter);
+
+	pr_debug("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+	/* Save Buffer id and size: template BxLyyyyyyyy*/
+	ret = kstrtol(&sub_str[1], 10, &bufid);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+		goto out;
+	}
+
+	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+		goto out;
+	}
+
+	*size = (size_t)bsize;
+	*buffer_id = (int)bufid;
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_buffer_size(_rpdev->ept);
+
+	if (msg_size < 0)
+		return msg_size;
+
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			return ret;
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+		if (!_buffer->vaddr) {
+			pr_err("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_debug("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot))
+			return -EAGAIN;
+
+		_buffer->uaddr = (void *)vma->vm_start;
+
+		/* Send information to remote proc */
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_debug("rpmsg_sdb(%s): Free the CMA allocation: pos->size:%08x, pos->vaddr:%08x, pos->paddr:%08x\n",
+					__func__,
+					pos->size,
+					pos->vaddr,
+					pos->paddr);
+
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,
+					pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+    //dev_err(rpmsg_sdb_dev, "(%s) lenght: %d\n", __func__,len);
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+		/* TODO: quid if nothing find during the loop ? */
+	}
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "rpmsg-sdb-channel" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+static int __init rpmsg_sdb_drv_init(void)
+{
+	int ret = 0;
+
+	/* Register rpmsg device */
+	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+	if (ret) {
+		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+		return ret;
+	}
+
+	pr_info("rpmsg_sdb: Init done\n");
+
+	return ret;
+}
+
+static void __exit rpmsg_sdb_drv_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+	pr_info("rpmsg_sdb: Exit\n");
+}
+
+module_init(rpmsg_sdb_drv_init);
+module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Jean-Philippe Romain <jean-philippe.romain@st.com>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/stm32_rpmsg_sdb (Kopie).c.old

@@ -0,0 +1,541 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) STMicroelectronics 2019 - All Rights Reserved
+ * Author: Jean-Philippe Romain <jean-philippe.romain@st.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+
+#define RPMSG_SDB_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "stm32-rpmsg-sdb";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_debug("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+
+	pr_debug("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+
+	/* Get first part containing the buffer id */
+	sub_str = strsep(&rxbuf_str, delimiter);
+
+	pr_debug("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+	/* Save Buffer id and size: template BxLyyyyyyyy*/
+	ret = kstrtol(&sub_str[1], 10, &bufid);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+		goto out;
+	}
+
+	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+		goto out;
+	}
+
+	*size = (size_t)bsize;
+	*buffer_id = (int)bufid;
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_mtu(_rpdev->ept);
+
+	if (msg_size < 0)
+		return msg_size;
+
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			return ret;
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+		if (!_buffer->vaddr) {
+			pr_err("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_debug("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot))
+			return -EAGAIN;
+
+		_buffer->uaddr = (void *)vma->vm_start;
+
+		/* Send information to remote proc */
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_debug("rpmsg_sdb(%s): Free the CMA allocation: pos->size:%08x, pos->vaddr:%08x, pos->paddr:%08x\n",
+					__func__,
+					pos->size,
+					pos->vaddr,
+					pos->paddr);
+
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,
+					pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+    //dev_err(rpmsg_sdb_dev, "(%s) lenght: %d\n", __func__,len);
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+		/* TODO: quid if nothing find during the loop ? */
+	}
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+	
+	pr_info("rpmsg_sdb: registering startetd\n");
+	
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	pr_info("rpmsg_sdb: Set Driver data\n");
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		pr_info("rpmsg_sdb: Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	pr_info("rpmsg_sdb: Failed to register device\n");
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "rpmsg-sdb-channel" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+static int __init rpmsg_sdb_drv_init(void)
+{
+	int ret = 0;
+
+	/* Register rpmsg device */
+	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+	if (ret) {
+		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+		return ret;
+	}
+
+	pr_info("rpmsg_sdb: Init done\n");
+
+	return ret;
+}
+
+static void __exit rpmsg_sdb_drv_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+	pr_info("rpmsg_sdb: Exit\n");
+}
+
+module_init(rpmsg_sdb_drv_init);
+module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Jean-Philippe Romain <jean-philippe.romain@st.com>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/ttyrpmsg.csave

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 STMicroelectronics - All Rights Reserved
+ *
+ * The rpmsg tty driver implements serial communication on the RPMsg bus to makes
+ * possible for user-space programs to send and receive rpmsg messages as a standard
+ * tty protocol.
+ *
+ * The remote processor can instantiate a new tty by requesting a "rpmsg-tty" RPMsg service.
+ * The "rpmsg-tty" service is directly used for data exchange. No flow control is implemented yet.
+ */
+
+#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#define RPMSG_TTY_NAME	"ttyRPMSG"
+#define MAX_TTY_RPMSG	32
+
+static DEFINE_IDR(tty_idr);	/* tty instance id */
+static DEFINE_MUTEX(idr_lock);	/* protects tty_idr */
+
+static struct tty_driver *rpmsg_tty_driver;
+
+struct rpmsg_tty_port {
+	struct tty_port		port;	 /* TTY port data */
+	int			id;	 /* TTY rpmsg index */
+	struct rpmsg_device	*rpdev;	 /* rpmsg device */
+};
+
+static int rpmsg_tty_cb(struct rpmsg_device *rpdev, void *data, int len, void *priv, u32 src)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+	int copied;
+
+	if (!len)
+		return -EINVAL;
+	copied = tty_insert_flip_string(&cport->port, data, len);
+	if (copied != len)
+		dev_err_ratelimited(&rpdev->dev, "Trunc buffer: available space is %d\n", copied);
+	tty_flip_buffer_push(&cport->port);
+
+	return 0;
+}
+
+static int rpmsg_tty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = idr_find(&tty_idr, tty->index);
+	struct tty_port *port;
+
+	tty->driver_data = cport;
+
+	port = tty_port_get(&cport->port);
+	return tty_port_install(port, driver, tty);
+}
+
+static void rpmsg_tty_cleanup(struct tty_struct *tty)
+{
+	tty_port_put(tty->port);
+}
+
+static int rpmsg_tty_open(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_open(tty->port, tty, filp);
+}
+
+static void rpmsg_tty_close(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_close(tty->port, tty, filp);
+}
+
+static int rpmsg_tty_write(struct tty_struct *tty, const u8 *buf, int len)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	struct rpmsg_device *rpdev;
+	int msg_max_size, msg_size;
+	int ret;
+
+	rpdev = cport->rpdev;
+
+	msg_max_size = rpmsg_get_mtu(rpdev->ept);
+	if (msg_max_size < 0)
+		return msg_max_size;
+
+	msg_size = min(len, msg_max_size);
+
+	/*
+	 * Use rpmsg_trysend instead of rpmsg_send to send the message so the caller is not
+	 * hung until a rpmsg buffer is available. In such case rpmsg_trysend returns -ENOMEM.
+	 */
+	ret = rpmsg_trysend(rpdev->ept, (void *)buf, msg_size);
+	if (ret) {
+		dev_dbg_ratelimited(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return msg_size;
+}
+
+static unsigned int rpmsg_tty_write_room(struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	int size;
+
+	size = rpmsg_get_mtu(cport->rpdev->ept);
+	if (size < 0)
+		return 0;
+
+	return size;
+}
+
+static void rpmsg_tty_hangup(struct tty_struct *tty)
+{
+	tty_port_hangup(tty->port);
+}
+
+static const struct tty_operations rpmsg_tty_ops = {
+	.install	= rpmsg_tty_install,
+	.open		= rpmsg_tty_open,
+	.close		= rpmsg_tty_close,
+	.write		= rpmsg_tty_write,
+	.write_room	= rpmsg_tty_write_room,
+	.hangup		= rpmsg_tty_hangup,
+	.cleanup	= rpmsg_tty_cleanup,
+};
+
+static struct rpmsg_tty_port *rpmsg_tty_alloc_cport(void)
+{
+	struct rpmsg_tty_port *cport;
+	int ret;
+
+	cport = kzalloc(sizeof(*cport), GFP_KERNEL);
+	if (!cport)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_lock(&idr_lock);
+	ret = idr_alloc(&tty_idr, cport, 0, MAX_TTY_RPMSG, GFP_KERNEL);
+	mutex_unlock(&idr_lock);
+
+	if (ret < 0) {
+		kfree(cport);
+		return ERR_PTR(ret);
+	}
+
+	cport->id = ret;
+
+	return cport;
+}
+
+static void rpmsg_tty_destruct_port(struct tty_port *port)
+{
+	struct rpmsg_tty_port *cport = container_of(port, struct rpmsg_tty_port, port);
+
+	mutex_lock(&idr_lock);
+	idr_remove(&tty_idr, cport->id);
+	mutex_unlock(&idr_lock);
+
+	kfree(cport);
+}
+
+static const struct tty_port_operations rpmsg_tty_port_ops = {
+	.destruct = rpmsg_tty_destruct_port,
+};
+
+
+static int rpmsg_tty_probe(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport;
+	struct device *dev = &rpdev->dev;
+	struct device *tty_dev;
+	int ret;
+
+	cport = rpmsg_tty_alloc_cport();
+	if (IS_ERR(cport))
+		return dev_err_probe(dev, PTR_ERR(cport), "Failed to alloc tty port\n");
+
+	tty_port_init(&cport->port);
+	cport->port.ops = &rpmsg_tty_port_ops;
+
+	tty_dev = tty_port_register_device(&cport->port, rpmsg_tty_driver,
+					   cport->id, dev);
+	if (IS_ERR(tty_dev)) {
+		ret = dev_err_probe(dev, PTR_ERR(tty_dev), "Failed to register tty port\n");
+		tty_port_put(&cport->port);
+		return ret;
+	}
+
+	cport->rpdev = rpdev;
+
+	dev_set_drvdata(dev, cport);
+
+	dev_dbg(dev, "New channel: 0x%x -> 0x%x: " RPMSG_TTY_NAME "%d\n",
+		rpdev->src, rpdev->dst, cport->id);
+
+	return 0;
+}
+
+static void rpmsg_tty_remove(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+
+	dev_dbg(&rpdev->dev, "Removing rpmsg tty device %d\n", cport->id);
+
+	/* User hang up to release the tty */
+	tty_port_tty_hangup(&cport->port, false);
+
+	tty_unregister_device(rpmsg_tty_driver, cport->id);
+
+	tty_port_put(&cport->port);
+}
+
+static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = {
+	{ .name	= "rpmsg-tty" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table);
+
+static struct rpmsg_driver rpmsg_tty_rpmsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= rpmsg_driver_tty_id_table,
+	.probe		= rpmsg_tty_probe,
+	.callback	= rpmsg_tty_cb,
+	.remove		= rpmsg_tty_remove,
+};
+
+static int __init rpmsg_tty_init(void)
+{
+	int ret;
+
+	rpmsg_tty_driver = tty_alloc_driver(MAX_TTY_RPMSG, TTY_DRIVER_REAL_RAW |
+					    TTY_DRIVER_DYNAMIC_DEV);
+	if (IS_ERR(rpmsg_tty_driver))
+		return PTR_ERR(rpmsg_tty_driver);
+
+	rpmsg_tty_driver->driver_name = "rpmsg_tty";
+	rpmsg_tty_driver->name = RPMSG_TTY_NAME;
+	rpmsg_tty_driver->major = 0;
+	rpmsg_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
+
+	/* Disable unused mode by default */
+	rpmsg_tty_driver->init_termios = tty_std_termios;
+	rpmsg_tty_driver->init_termios.c_lflag &= ~(ECHO | ICANON);
+	rpmsg_tty_driver->init_termios.c_oflag &= ~(OPOST | ONLCR);
+
+	tty_set_operations(rpmsg_tty_driver, &rpmsg_tty_ops);
+
+	ret = tty_register_driver(rpmsg_tty_driver);
+	if (ret < 0) {
+		pr_err("Couldn't install driver: %d\n", ret);
+		goto error_put;
+	}
+
+	ret = register_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	if (ret < 0) {
+		pr_err("Couldn't register driver: %d\n", ret);
+		goto error_unregister;
+	}
+
+	return 0;
+
+error_unregister:
+	tty_unregister_driver(rpmsg_tty_driver);
+
+error_put:
+	tty_driver_kref_put(rpmsg_tty_driver);
+
+	return ret;
+}
+
+static void __exit rpmsg_tty_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	tty_unregister_driver(rpmsg_tty_driver);
+	tty_driver_kref_put(rpmsg_tty_driver);
+	idr_destroy(&tty_idr);
+}
+
+module_init(rpmsg_tty_init);
+module_exit(rpmsg_tty_exit);
+
+MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>");
+MODULE_DESCRIPTION("remote processor messaging tty driver");
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-mon-datafile (Kopie).c.save

@@ -0,0 +1,553 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+
+#define VRPMDV_MON_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "vrpmdv-mon-datafile";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_debug("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+
+	pr_debug("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+
+	/* Get first part containing the buffer id */
+	sub_str = strsep(&rxbuf_str, delimiter);
+
+	pr_debug("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+	/* Save Buffer id and size: template BxLyyyyyyyy*/
+	ret = kstrtol(&sub_str[1], 10, &bufid);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+		goto out;
+	}
+
+	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+		goto out;
+	}
+
+	*size = (size_t)bsize;
+	*buffer_id = (int)bufid;
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_mtu(_rpdev->ept);
+
+	if (msg_size < 0)
+		return msg_size;
+
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			return ret;
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+		if (!_buffer->vaddr) {
+			pr_err("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_debug("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot))
+			return -EAGAIN;
+
+		_buffer->uaddr = (void *)vma->vm_start;
+
+		/* Send information to remote proc */
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_debug("rpmsg_sdb(%s): Free the CMA allocation: pos->size:%08x, pos->vaddr:%08x, pos->paddr:%08x\n",
+					__func__,
+					pos->size,
+					pos->vaddr,
+					pos->paddr);
+
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,
+					pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+    //dev_err(rpmsg_sdb_dev, "(%s) lenght: %d\n", __func__,len);
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+		/* TODO: quid if nothing find during the loop ? */
+	}
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "rpmsg-sdb-channel" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+static int __init rpmsg_sdb_drv_init(void)
+{
+	int ret = 0;
+
+	/* Register rpmsg device */
+	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+	if (ret) {
+		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+		return ret;
+	}
+
+	pr_info("rpmsg_sdb: Init done\n");
+
+	return ret;
+}
+
+static void __exit rpmsg_sdb_drv_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+	pr_info("rpmsg_sdb: Exit\n");
+}
+
+module_init(rpmsg_sdb_drv_init);
+module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Jean-Philippe Romain <jean-philippe.romain@st.com>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-mon-datafile copy.c

@@ -0,0 +1,552 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+
+#define VRPMDV_MON_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char vrpmdv_mon_datafile[] = "vrpmdv-mon-datafile";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_debug("vrpmdv-mon-datafile(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+
+	pr_debug("vrpmdv-mon-datafile(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+
+	/* Get first part containing the buffer id */
+	sub_str = strsep(&rxbuf_str, delimiter);
+
+	pr_debug("vrpmdv-mon-datafile(%s): sub_str:%s\n", __func__, sub_str);
+
+	/* Save Buffer id and size: template BxLyyyyyyyy*/
+	ret = kstrtol(&sub_str[1], 10, &bufid);
+	if (ret < 0) {
+		pr_err("vrpmdv-mon-datafile(ERROR): Extract of buffer id failed(%d)", ret);
+		goto out;
+	}
+
+	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+	if (ret < 0) {
+		pr_err("vrpmdv-mon-datafile(ERROR): Extract of buffer size failed(%d)", ret);
+		goto out;
+	}
+
+	*size = (size_t)bsize;
+	*buffer_id = (int)bufid;
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_mtu(_rpdev->ept);
+
+	if (msg_size < 0)
+		return msg_size;
+
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "vrpmdv-mon-datafile failed: %d\n", ret);
+			return ret;
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+		if (!_buffer->vaddr) {
+			pr_err("vrpmdv-mon-datafile(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_debug("vrpmdv-mon-datafile(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot))
+			return -EAGAIN;
+
+		_buffer->uaddr = (void *)vma->vm_start;
+
+		/* Send information to remote proc */
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_debug("vrpmdv-mon-datafile(%s): Free the CMA allocation: pos->size:%08x, pos->vaddr:%08x, pos->paddr:%08x\n",
+					__func__,
+					pos->size,
+					pos->vaddr,
+					pos->paddr);
+
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,
+					pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				pr_err("vrpmdv-mon-datafile(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			pr_err("vrpmdv-mon-datafile(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("vrpmdv-mon-datafile(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("vrpmdv-mon-datafile(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner		= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap		= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+    //dev_err(rpmsg_sdb_dev, "(%s) lenght: %d\n", __func__,len);
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+		/* TODO: quid if nothing find during the loop ? */
+	}
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "vrpmdv-mon-datafile"; //rpmsg-sdb
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	dev_info(dev, "%s probed\n", vrpmdv_mon_datafile);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "vrpmdv-mon-datafile" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+static int __init rpmsg_sdb_drv_init(void)
+{
+	int ret = 0;
+
+	/* Register rpmsg device */
+	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+	if (ret) {
+		pr_err("vrpmdv-mon-datafile(ERROR): Failed to register device\n");
+		return ret;
+	}
+
+	pr_info("vrpmdv-mon-datafile: Init done\n");
+
+	return ret;
+}
+
+static void __exit rpmsg_sdb_drv_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+	pr_info("vrpmdv-mon-datafile: Exit\n");
+}
+
+module_init(rpmsg_sdb_drv_init);
+module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Markus Lehr <markus@malehr.de>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(VRPMDV_MON_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-mon-datafile-before-DMA-Change.c

@@ -0,0 +1,706 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) STMicroelectronics 2019 - All Rights Reserved
+ * Author: Jean-Philippe Romain <jean-philippe.romain@st.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+#include <linux/types.h>
+
+#define RPMSG_SDB_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "vrpmdv-mon-datafile";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+struct vRCMDeviceData {
+	uint32_t  packageNo;  //current package Number
+	uint32_t  packageCount; //complete package Number
+	uint32_t  dataQuantity;	//number of uint32_t in data
+	uint32_t  data[]; //the data
+};
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_info("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+	//__u32* data = (__u32*) rxbuf_str;
+	struct vRCMDeviceData* pdata = (struct vRCMDeviceData*) rxbuf_str;
+
+
+	//pr_info("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+	pr_info("rpmsg_sdb(%s): packageno:%d\n", __func__, pdata->packageNo);
+	pr_info("rpmsg_sdb(%s): packageCount:%d\n", __func__, pdata->packageCount);
+	pr_info("rpmsg_sdb(%s): dataquantity:%d\n", __func__, pdata->dataQuantity);	
+	pr_info("rpmsg_sdb(%s): data:%d\n", __func__, (pdata->data)[0]);
+	// pr_info("rpmsg_sdb(%s): rxbuf_str:%d\n", __func__, data[0]);
+	// pr_info("rpmsg_sdb(%s): rxbuf_str:%d\n", __func__, data[1]);
+	// pr_info("rpmsg_sdb(%s): rxbuf_str:%d\n", __func__, data[2]);
+	
+
+
+	/* Get first part containing the buffer id */
+// 	sub_str = strsep(&rxbuf_str, delimiter);
+
+// //	pr_info("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+// 	/* Save Buffer id and size: template BxLyyyyyyyy*/
+// 	ret = kstrtol(&sub_str[1], 10, &bufid);
+// 	if (ret < 0) {
+// //		pr_info("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+// 		goto out;
+// 	}
+
+// 	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+// 	if (ret < 0) {
+// //		pr_info("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+// 		goto out;
+// 	}
+
+// 	*size = (size_t)bsize;
+// 	*buffer_id = (int)bufid;
+
+// out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	pr_info("rpmsg_sdb(%s): start rpmsg_sdb_send_buf_info\n", __func__);
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_mtu(_rpdev->ept);
+
+	pr_info("rpmsg_sdb(%s): checked msg site:%d\n", __func__, msg_size);
+	if (msg_size < 0)
+		return msg_size;
+
+	pr_info("rpmsg_sdb(%s): Call rpmsg_sdb_format_txbuf_string\n",	__func__);
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		pr_info("rpmsg_sdb(%s): send a message to our remote processor\n", __func__);		
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			pr_info("rpmsg_sdb(%s): error by send a message to our remote processor\n", __func__);					
+			return ret;
+		}
+		else {
+			pr_info("rpmsg_sdb(%s): send succesfully a message to our remote processor\n", __func__);
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	pr_info("rpmsg_sdb(%s): start rpmsg_sdb_mmap\n", __func__);
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	pr_info("rpmsg_sdb(%s): start rpmsg_sdb_mmap - coherent_dma_mask\n", __func__);
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		pr_info("rpmsg_sdb(%s): start rpmsg_sdb_mmap - bufferlist not empty\n", __func__);		
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+
+		if (!_buffer->vaddr) {
+			pr_info("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_info("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot)) {
+
+			pr_info("rpmsg_sdb(%s): remap_pfn_range could not be done\n");
+			return -EAGAIN;
+		}
+
+
+		_buffer->uaddr = (void *)vma->vm_start;
+		pr_info("rpmsg_sdb(%s): _buffer->uaddr = %p\n",	__func__, _buffer->uaddr);
+
+		/* Send information to remote proc */
+		pr_info("rpmsg_sdb(%s): Send information to remote proc\n",	__func__);
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		pr_debug("rpmsg_sdb(%s): No existing buffer entry exist in the list !!!\n", __func__);				
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	pr_debug("rpmsg_sdb(%s): Init bufferlist", __func__);
+	pr_info("rpmsg_sdb(%s): start Init bufferlist", __func__);		
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+	pr_info("rpmsg_sdb(%s): success Init bufferlist", __func__);			
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_info("rpmsg_sdb(%s): Free the CMA allocation 3", __func__);
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,	pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	pr_info("rpmsg_sdb(%s): Free the CMA allocation 4 - done", __func__);
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		pr_info("mon-datafile: set EFD\n");		
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				// pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				pr_info("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");		
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			// pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			pr_info("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");		
+
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+		
+		pr_info("rpmsg_sdb(SUCCES): RPMSG_SDB_IOCTL_SET_EFD \n");		
+		
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		pr_info("mon-datafile: get datasize\n");
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	//pr_info("mon-datafile: receive msg from Copro: %s, len:%d\n", __func__, len);
+
+	// struct rpmsg_sdb_t {
+	// 	struct mutex	mutex; /* mutex to protect the ioctls */
+	// 	struct miscdevice mdev; /* misc device ref */
+	// 	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	// 	struct list_head buffer_list; /* buffer instances list */
+	// };
+
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	// ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    
+	// if (ret < 0)
+	// 	goto out;
+
+	// if (buffer_id > LastBufferId) {
+	// 	ret = -EINVAL;
+	// 	goto out;
+	// }
+
+	struct vRCMDeviceData* pdata = (struct vRCMDeviceData*) rpmsg_RxBuf;
+
+
+	//pr_info("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+	// pr_info("rpmsg_sdb(%s): packageno:%d\n", __func__, pdata->packageNo);
+	// pr_info("rpmsg_sdb(%s): packageCount:%d\n", __func__, pdata->packageCount);
+	// pr_info("rpmsg_sdb(%s): dataquantity:%d\n", __func__, pdata->dataQuantity);	
+	// pr_info("rpmsg_sdb(%s): data:%d\n", __func__, (pdata->data)[0]);
+
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+	if (drv == NULL) {
+		dev_err(rpmsg_sdb_dev, "(%s) no driver found\n", __func__);		
+		return -EINVAL;		
+	}
+    
+	//copy data to structure
+	//1. get buffer
+
+	// struct vRCMDeviceData* pdata = (struct vRCMDeviceData*) kmalloc(len+1, GFP_KERNEL);
+	// memcpy(pdata, data, len);
+
+	// if (ret < 0)
+	// 	goto out;
+
+	// if (buffer_id > LastBufferId) {
+	// 	ret = -EINVAL;
+	// 	goto out;
+	// }
+
+
+/** 
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+*/
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+
+
+		/**
+		 * struct vRCMDeviceData {
+				uint32_t  packageNo;  //current package Number
+				uint32_t  packageCount; //complete package Number
+				uint32_t  dataQuantity;	//number of uint32_t in data
+				uint32_t  data[]; //the data
+			};
+		 */
+		//copy data to buffer
+
+
+	// struct sdb_buf_t {
+	// 	int index; /* index of buffer */
+	// 	size_t size; /* buffer size */
+	// 	size_t writing_size; /* size of data written by copro */
+	// 	dma_addr_t paddr; /* physical address*/
+	// 	void *vaddr; /* virtual address */
+	// 	void *uaddr; /* mapped address for userland */
+	// 	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	// 	struct list_head buflist; /* reference in the buffers list */
+	// };
+
+		//get the buffer as array of struct vRCMDeviceData
+		struct vRCMDeviceData* vrBuff = (struct vRCMDeviceData*) (datastructureptr->vaddr);
+		struct vRCMDeviceData* startAdress =  &(vrBuff[pdata->packageNo]);
+		// pr_info("rpmsg_sdb(%s): startAdress:%d\n", __func__, startAdress);
+
+		if (virt_addr_valid(startAdress)) {
+			// pr_info("rpmsg_sdb(%s): startAdress:%d is valid\n", __func__, startAdress);			
+			memcpy(startAdress, rpmsg_RxBuf, len);		
+		}
+		else {
+			pr_info("rpmsg_sdb(%s): startAdress[%d]:%p is invalid!!\n", __func__, startAdress);						
+		}
+
+
+		// if (datastructureptr->index == buffer_id) {
+		// 	datastructureptr->writing_size = buffer_size;
+
+		// 	if (datastructureptr->writing_size > datastructureptr->size) {
+		// 		dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+		// 		ret = -EINVAL;
+		// 		goto out;
+		// 	}
+
+		if ((pdata != NULL) && (pdata->packageNo == pdata->packageCount)) {
+			pr_info("rpmsg_sdb(%s): signal bufferfull!\n", __func__);									
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+
+		}
+
+	}
+
+
+	/* Signal to User space application */
+/** list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+	}
+*/
+
+out:
+	kfree(rpmsg_RxBuf);
+	kfree(pdata);
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+	
+	pr_info("mon-datafile: registering started\n");
+	
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "mon-datafile";//"rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	pr_info("mon-datafile: Set Driver data\n");
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		pr_info("mon-datafile: Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	//pr_info("rpmsg_sdb: Failed to register device\n");
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "vrpmdv-mon-datafile" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+//static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+static struct rpmsg_driver vrpmdv_monitoring_data = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+module_rpmsg_driver(vrpmdv_monitoring_data);
+
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Markus Lehr <markus@malehr.de>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-mon-datafile.c.old

@@ -0,0 +1,28 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+
+MODULE_AUTHOR("Markus Lehr <markus@malehr.de>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(VRPMDV_MON_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-monitoring-controler.cold

@@ -0,0 +1,804 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+#include <linux/wait.h>
+
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+//#include "vrpmdv-monitoring-cmd.h"
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+
+#define MSG		"hello Monitoring!"
+
+static int count = 100;
+module_param(count, int, 0644);
+
+struct instance_data {
+	int rx_count;
+};
+
+
+// std::chrono::seconds timeoutPeriod = 5;
+// auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+/**
+ * Generic Netlink will create a Netlink family with this name. Kernel will asign
+ * a numeric ID and afterwards we can talk to the family with its ID. To get
+ * the ID we use Generic Netlink in the userland and pass the family name.
+ *
+ * Short for: Generic Netlink VRPMDV Monitoring  gnl_foobar_mcmd
+ */
+#define FAMILY_NAME "gnl-vrpmdv-mcmd"
+
+/**
+ * These are the attributes that we want to share in gnl_foobar_xmpl.
+ * You can understand an attribute as a semantic type. This is
+ * the payload of Netlink messages.
+ * GNl: Generic Netlink
+ */
+enum GNL_VRPMDV_XMPL_ATTRIBUTE {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_A_UNSPEC,
+    /** We expect a MSG to be a null-terminated C-string. */
+    GNL_VRPMDV_MCMD_A_MSG,
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_A_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN (__GNL_VRPMDV_MCMD_A_MAX)
+/**
+ * The number of actual usable attributes in `enum GNL_VRPMDV_MCMD_ATTRIBUTE`.
+ * This is `GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_COUNT (GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN - 1)
+
+/**
+ * Enumeration of all commands (functions) that our custom protocol on top
+ * of generic netlink supports. This can be understood as the action that
+ * we want to trigger on the receiving side.
+ */
+enum GNL_VRPMDV_MCMD_COMMAND {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_C_UNSPEC,
+
+    // first real command is "1" (>0)
+    /**
+     * When this command is received, we expect the attribute `GNL_VRPMDV_MCMD_ATTRIBUTE::GNL_VRPMDV_MCMD_A_MSG` to
+     * be present in the Generic Netlink request message. The kernel reads the message from the packet and
+     * sent it to the copro. THe result will be return by creating a new Generic Netlink response message 
+     * with an corresponding attribute/payload.
+     *
+     * This command/signaling mechanism is independent of the Netlink flag `NLM_F_ECHO (0x08)`. We use it as
+     * "echo specific data" instead of return a 1:1 copy of the package, which you could do with
+     * `NLM_F_ECHO (0x08)` for example.
+     */
+    GNL_VRPMDV_MCMD_C_MSG,
+
+    /**
+     * Provokes a NLMSG_ERR answer to this request as described in netlink manpage
+     * (https://man7.org/linux/man-pages/man7/netlink.7.html).
+     */
+    GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_C_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN (__GNL_VRPMDV_MCMD_C_MAX)
+/**
+ * The number of actual usable commands  in `enum GNL_FOOBAR_XMPL_COMMAND`.
+ * This is `GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_COUNT (GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN - 1)
+
+#define NODATARECEIVED 0
+#define DATARECEIVED 1
+
+/**
+ * Data structure required for our .doit callback handler to
+ * know about the progress of an ongoing cmd execution.
+ * See the cmd callback handler how it is used.
+ */
+// struct {
+//     // from <linux/mutex.h>
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex sendMTX;
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex receiveCV;
+//     /**
+//      * Wait Queue: if it is signaled we have received data from copro
+//     */
+//     wait_queue_head_t receive_queue;
+//     /**
+//      * Waitflag: 0= no data received, 1 = data received
+//     */
+//     int receive_queue_flag = NODATARECEIVED;
+//     /**
+//      * Condition vaiable signal we have received data from copro
+//     */
+// //    std::condition_variable cv;
+//     // /**
+//     //  * Number that describes how many packets we need to send until we are done
+//     //  * during an ongoing dumpit process. 0 = done.
+//     //  */
+//     // int unsigned runs_to_go;
+//     // /**
+//     //  * Number that describes how many packets per dump are sent in total.
+//     //  * Constant per dump.
+//     //  */
+//     // int unsigned total_runs;
+
+//     //the rpmsg device which sends the data to the copro 
+//     struct rpmsg_device	*rpdev;	/* handle rpmsg device */    
+// } cmd_cb_progress_data;
+
+
+struct rpmsg_vrpmdv_mon_t{
+    // from <linux/mutex.h>
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex sendMTX;
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex receiveCV;
+    /**
+     * Wait Queue: if it is signaled we have received data from copro
+    */
+    wait_queue_head_t receive_queue;
+    /**
+     * Waitflag: 0= no data received, 1 = data received
+    */
+    int receive_queue_flag;
+    //the rpmsg device which sends the data to the copro 
+    struct rpmsg_device* rpdev;	/* handle rpmsg device */    
+};
+
+struct rpmsg_vrpmdv_mon_t vrpmdv_mon;
+
+	// struct mutex	mutex; /* mutex to protect the ioctls */
+	// struct miscdevice mdev; /* misc device ref */
+	// struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	// struct list_head buffer_list; /* buffer instances list */
+
+
+
+// Documentation is on the implementation of this function.
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_VRPMDV_OPS_LEN (GNL_VRPMDV_MCMD_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_vrpmdv_mcmd_ops[GNL_VRPMDV_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_VRPMDV_MCMD_C_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_vrpmdv_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = NULL, //gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = NULL, //gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = NULL, //gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_vrpmdv_mcmd_policy[GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_VRPMDV_MCMD_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_VRPMDV_MCMD_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_vrpmdv_mcmd_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_vrpmdv_mcmd_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_VRPMDV_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_vrpmdv_mcmd_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_VRPMDV_MCMD_C_MSG` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_vrpmdv_mcmd_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_VRPMDV_MCMD_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_VRPMDV_MCMD_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+    //aquire lock for cmd repmsg channel     
+    // std::lock sendlk(cmd_cb_progress_data.sendmtx);    
+
+    //send the message to the copro over RPMSG 
+	rc = rpmsg_send(vrpmdv_mon.rpdev->ept, recv_msg, strlen(recv_msg));
+	if (rc) {
+		pr_err("rpmsg_send failed: %d\n", rc);
+		return rc;
+	}
+
+	// struct rpmsg_vrpmdv_mon_t *drv = dev_get_drvdata(&rpdev->dev);
+
+    {
+        pr_info("wait for response\n");
+        // wait until receive_queue_flag=1 , that means we have received data from Copro
+        wait_event_interruptible(vrpmdv_mon.receive_queue, vrpmdv_mon.receive_queue_flag != 0 );
+        pr_info("received data \n");
+        //Copy data
+        vrpmdv_mon.receive_queue_flag = NODATARECEIVED;
+
+
+
+        // std::unique_lock lk(cmd_cb_progress_data.receivemtx);
+        // if (myCondVar.wait_until(uLock, timePoint) == std::cv_status::timeout)
+        // {
+		//     dev_err(&cmd_cb_progress_data.rpdev, "rpmsg_send failed, timeout: \n");
+        //     return -1:
+        // }
+
+        pr_info("get response: '%s'\n", recv_msg);
+    }
+
+
+
+    // Send a message back after we receive the reply from rpmsg channel
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    // msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+    //                        // According to my findings: this is not used for routing
+    //                        // This can be used in an application specific way to target
+    //                        // different endpoints within the same user application
+    //                        // but general rule: just put sender port id here
+    //                        info->snd_portid, // sending port (not process) id: int
+    //                        info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+    //                        &gnl_vrpmdv_mcmd_family, // struct genl_family *
+    //                        0, // flags for Netlink header: int; application specific and not mandatory
+    //                        // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+    //                        GNL_VRPMDV_MCMD_C_MSG
+    // );
+
+    msg_head = genlmsg_put_reply(reply_skb, // buffer for netlink message: struct sk_buff *
+                                info, // info
+                                &gnl_vrpmdv_mcmd_family, // struct genl_family *
+                                0, // flags for Netlink header: int; application specific and not mandatory
+                                // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                                info->genlhdr->cmd
+    );
+
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_VRPMDV_MCMD_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_VRPMDV_MCMD_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+
+
+
+/**
+ * callback that is called after the copro send data
+ * we have to copy it in a buffer for the netlink and later send it back to the userland
+ * 
+*/
+static int vrpmdv_monitoring_cb(struct rpmsg_device *rpdev, void *data, int len,
+						void *priv, u32 src)
+{
+	int ret = 0;
+	struct instance_data *idata = dev_get_drvdata(&rpdev->dev);
+
+	dev_info(&rpdev->dev, "incoming msg %d (src: 0x%x)\n",
+		 ++idata->rx_count, src);
+
+	print_hex_dump_debug(__func__, DUMP_PREFIX_NONE, 16, 1, data, len,
+			     true);
+
+    vrpmdv_mon.receive_queue_flag= DATARECEIVED;
+    wake_up_interruptible(&(vrpmdv_mon.receive_queue));
+
+	// /* samples should not live forever */
+	// if (idata->rx_count >= count) {
+	// 	dev_info(&rpdev->dev, "goodbye!\n");
+	// 	return 0;
+	// }
+
+	/* send a new message now */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret)
+	// 	dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+
+	return ret;
+}
+
+static int vrpmdv_monitoring_probe(struct rpmsg_device *rpdev)
+{
+    int rc;	
+
+	// int ret;
+	// struct instance_data *idata;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+					rpdev->src, rpdev->dst);
+
+	// idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	// if (!idata)
+	// 	return -ENOMEM;
+
+	// dev_set_drvdata(&rpdev->dev, idata);
+
+	// /* send a message to our remote processor to */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret) {
+	// 	dev_err(&rpdev->dev, "vrpmdv_monitoring_controler_send failed: %d\n", ret);
+	// 	return ret;
+	// }
+
+	// return 0;
+
+	// struct device *dev;
+    // dev = &rpdev->dev;
+	// struct rpmsg_vrpmdv_mon_t *rpmsg_vrpmdv_mon;
+
+	// rpmsg_vrpmdv_mon = devm_kzalloc(dev, sizeof(*rpmsg_vrpmdv_mon), GFP_KERNEL);
+	// if (!rpmsg_vrpmdv_mon)
+	// 	return -ENOMEM;
+
+    mutex_init(&(vrpmdv_mon.sendMTX));
+    init_waitqueue_head (&(vrpmdv_mon.receive_queue));    
+	vrpmdv_mon.rpdev = rpdev;
+
+	// dev_set_drvdata(&rpdev->dev, rpmsg_vrpmdv_mon);
+    pr_info("RPMSG CMD Device set.\n");
+
+
+	/** NEU **/
+    // if (cmd_cb_progress_data.rpdev == NULL) {
+     // cmd_cb_progress_data.rpdev = rpdev;
+     // pr_info("RPMSG CMD Device set.\n");
+    // }
+    // else {
+    //     pr_info("Error: RPMSG CMD Device already set. Don't set it twice\n");        
+    // }
+
+    pr_info("Generic Netlink VRPMDV-Monitroring_Controler Module started.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_vrpmdv_mcmd_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    return 0;
+
+
+
+}
+
+static void vrpmdv_monitoring_remove(struct rpmsg_device *rpdev)
+{
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_vrpmdv_mcmd_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&(vrpmdv_mon.sendMTX));
+    wake_up_interruptible(&(vrpmdv_mon.receive_queue));
+	
+	dev_info(&rpdev->dev, "vrpmdv-monitoring controler driver is removed\n");
+
+}
+
+static struct rpmsg_device_id vrpmdv_monitoring_controler_id_table[] = {
+	{ .name	= "vrpmdv-monitoring-controler" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, vrpmdv_monitoring_controler_id_table);
+
+static struct rpmsg_driver vrpmdv_monitoring_controler = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= vrpmdv_monitoring_controler_id_table,
+	.probe		= vrpmdv_monitoring_probe,
+	.callback	= vrpmdv_monitoring_cb,
+	.remove		= vrpmdv_monitoring_remove,
+};
+module_rpmsg_driver(vrpmdv_monitoring_controler);
+
+
+// static struct rpmsg_driver vrpmdv_monitoring_data = {
+// 	.drv.name	= KBUILD_MODNAME,
+// 	.id_table	= vrpmdv_monitoring_controler_id_table,
+// 	.probe		= vrpmdv_monitoring_probe,
+// 	.callback	= vrpmdv_monitoring_cb,
+// 	.remove		= vrpmdv_monitoring_remove,
+// };
+
+// module_rpmsg_driver(vrpmdv_monitoring_data);
+
+MODULE_DESCRIPTION("Remote processor messaging vrpmdv monitoring controler");
+MODULE_LICENSE("GPL v2");
+
+
+
+// /**
+//  * Module/driver initializer. Called on module load/insertion.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static int __init gnl_foobar_xmpl_module_init(void) {
+//     int rc;
+//     pr_info("Generic Netlink Example Module inserted.\n");
+
+//     // Register family with its operations and policies
+//     rc = genl_register_family(&gnl_foobar_xmpl_family);
+//     if (rc != 0) {
+//         pr_err("FAILED: genl_register_family(): %i\n", rc);
+//         pr_err("An error occurred while inserting the generic netlink example module\n");
+//         return -1;
+//     } else {
+//         pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_init(&dumpit_cb_progress_data.mtx);
+
+//     return 0;
+// }
+
+// /**
+//  * Module/driver uninitializer. Called on module unload/removal.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static void __exit gnl_foobar_xmpl_module_exit(void) {
+//     int ret;
+//     pr_info("Generic Netlink Example Module unloaded.\n");
+
+//     // Unregister the family
+//     ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+//     if (ret != 0) {
+//         pr_err("genl_unregister_family() failed: %i\n", ret);
+//         return;
+//     } else {
+//         pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_destroy(&dumpit_cb_progress_data.mtx);
+// }
+
+
+// ----
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-monitoring-driver copy.bb.old

@@ -0,0 +1,24 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "CLOSED"
+# LICENSE = "GPL-2.0-only"
+# LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://stm32_rpmsg_sdb.c \
+          "
+# file://75-rpmsg-sdb.rules \
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+# do_install:append() {
+    # udev rules for rpmsg-sdb
+    # install -d ${D}${sysconfdir}/udev/rules.d/
+    # install -m 0644 ${WORKDIR}/75-rpmsg-sdb.rules ${D}${sysconfdir}/udev/rules.d/75-rpmsg-sdb.rules
+# }
+#FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring-driver"

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-monitoring-driver copy1.bb.old

@@ -0,0 +1,26 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+           file://75-vrpmdv-monitoring.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for vrpmdv-monitoring
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-vrpmdv-monitoring.rules ${D}${sysconfdir}/udev/rules.d/75-vrpmdv-monitoring.rules
+}
+
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/save/vrpmdv-monitoring-driverv2.bb.old

@@ -0,0 +1,26 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+           file://75-vrpmdv-monitoring.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for vrpmdv-monitoring
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-vrpmdv-monitoring.rules ${D}${sysconfdir}/udev/rules.d/75-vrpmdv-monitoring.rules
+}
+
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+FILES:${PN} += "${base_libdir}/modules/"
+
+RPROVIDES:${PN} += "vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-mon-datafile/vrpmdv-mon-datafile.bb

@@ -0,0 +1,25 @@
+SUMMARY = "VRPMDV Monitoring Controler"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-mon-datafile.c \
+           file://75-mon-datafile.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for rpmsg-sdb
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-mon-datafile.rules ${D}${sysconfdir}/udev/rules.d/75-mon-datafile.rules
+}
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-mon-datafile"

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "files.associations": {
+        "rpmsg.h": "c",
+        "types.h": "c",
+        "ioctl.h": "c",
+        "wait.h": "c"
+    }
+}

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/files/75-mon-tty.rules

@@ -0,0 +1 @@
+SUBSYSTEM=="misc", KERNEL=="ttyMON", GROUP="tty", MODE="0666"

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/files/Makefile

@@ -0,0 +1,26 @@
+# Makefile for VRPMDV Monitoring Controler 
+obj-m := vrpmdv-mon-tty.o
+
+
+SRC := $(shell pwd)
+
+all:
+	$(MAKE) -C $(KERNEL_SRC) M=$(SRC)
+
+modules_install:
+	$(MAKE) -C $(KERNEL_SRC) M=$(SRC) modules_install
+
+clean:
+	rm -f *.o *~ core .depend .*.cmd *.ko *.mod.c
+	rm -f Module.markers Module.symvers modules.order
+	rm -rf .tmp_versions Modules.symvers
+
+# obj-m = vrpmdv-monitoring-controler.o
+
+# KVERSION = $(shell uname -r)
+
+# all:
+# 	make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
+
+# clean:
+# 	make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/files/lock.csave

@@ -0,0 +1,116 @@
+include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <thread>
+ 
+std::mutex m;
+std::condition_variable cv;
+std::string data;
+bool ready = false;
+bool processed = false;
+ 
+void worker_thread()
+{
+    // wait until main() sends data
+    std::unique_lock lk(m);
+    cv.wait(lk, []{ return ready; });
+ 
+    // after the wait, we own the lock
+    std::cout << "Worker thread is processing data\n";
+    data += " after processing";
+ 
+    // send data back to main()
+    processed = true;
+    std::cout << "Worker thread signals data processing completed\n";
+ 
+    // manual unlocking is done before notifying, to avoid waking up
+    // the waiting thread only to block again (see notify_one for details)
+    lk.unlock();
+    cv.notify_one();
+}
+ 
+int main()
+{
+    std::thread worker(worker_thread);
+ 
+    data = "Example data";
+    // send data to the worker thread
+    {
+        std::lock_guard lk(m);
+        ready = true;
+        std::cout << "main() signals data ready for processing\n";
+    }
+    cv.notify_one();
+ 
+    // wait for the worker
+    {
+        std::unique_lock lk(m);
+        cv.wait(lk, []{ return processed; });
+    }
+    std::cout << "Back in main(), data = " << data << '\n';
+ 
+    worker.join();
+}
+
+--------------------
+
+// waiting for timeout after 5 seconds
+std::chrono::seconds timeoutPeriod = 5;
+auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+std::unique_lock<std::mutex> uLock(myDataMutex);
+while(!DataAreReadyForProcessing())
+{
+    if (myCondVar.wait_until(uLock, timePoint) //<##
+        == std::cv_status::timeout)
+    {
+        // data conditions where not fulfilled within
+        // the time period; e.g. do some error handling
+        break;
+    }
+}
+
+--
+
+if (myCondVar.wait_for(uLock, timeoutPeriod,
+    DataAreReadyForProcessing))
+{
+    // data conditions where fulfilled
+    // regular processing
+}
+else // timeout occured, conditions are not fulfilled
+{
+    // e.g. do some error handling
+}
+
+
+
+
+
+
+-------------
+
+
+static int rpmsg_sample_probe(struct rpmsg_device *rpdev)
+{
+
+	int ret;
+	struct instance_data *idata;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+					rpdev->src, rpdev->dst);
+
+	idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	if (!idata)
+		return -ENOMEM;
+
+	dev_set_drvdata(&rpdev->dev, idata);
+
+	/* send a message to our remote processor */
+	ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	if (ret) {
+		dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return 0;

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/files/vrpmdv-mon-log.c.old

@@ -0,0 +1,795 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+#include <linux/wait.h>
+
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+//#include "vrpmdv-monitoring-cmd.h"
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+
+#define MSG		"hello Monitoring!"
+static bool retok = true;
+
+static int count = 100;
+module_param(count, int, 0644);
+
+struct instance_data {
+	int rx_count;
+};
+
+
+// std::chrono::seconds timeoutPeriod = 5;
+// auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+/**
+ * Generic Netlink will create a Netlink family with this name. Kernel will asign
+ * a numeric ID and afterwards we can talk to the family with its ID. To get
+ * the ID we use Generic Netlink in the userland and pass the family name.
+ *
+ * Short for: Generic Netlink VRPMDV Monitoring  gnl_foobar_mcmd
+ */
+#define FAMILY_NAME "gnl-vrpmdv-mcmd"
+
+/**
+ * These are the attributes that we want to share in gnl_foobar_xmpl.
+ * You can understand an attribute as a semantic type. This is
+ * the payload of Netlink messages.
+ * GNl: Generic Netlink
+ */
+enum GNL_VRPMDV_XMPL_ATTRIBUTE {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_A_UNSPEC,
+    /** We expect a MSG to be a null-terminated C-string. */
+    GNL_VRPMDV_MCMD_A_MSG,
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_A_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN (__GNL_VRPMDV_MCMD_A_MAX)
+/**
+ * The number of actual usable attributes in `enum GNL_VRPMDV_MCMD_ATTRIBUTE`.
+ * This is `GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_COUNT (GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN - 1)
+
+/**
+ * Enumeration of all commands (functions) that our custom protocol on top
+ * of generic netlink supports. This can be understood as the action that
+ * we want to trigger on the receiving side.
+ */
+enum GNL_VRPMDV_MCMD_COMMAND {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_C_UNSPEC,
+
+    // first real command is "1" (>0)
+    /**
+     * When this command is received, we expect the attribute `GNL_VRPMDV_MCMD_ATTRIBUTE::GNL_VRPMDV_MCMD_A_MSG` to
+     * be present in the Generic Netlink request message. The kernel reads the message from the packet and
+     * sent it to the copro. THe result will be return by creating a new Generic Netlink response message 
+     * with an corresponding attribute/payload.
+     *
+     * This command/signaling mechanism is independent of the Netlink flag `NLM_F_ECHO (0x08)`. We use it as
+     * "echo specific data" instead of return a 1:1 copy of the package, which you could do with
+     * `NLM_F_ECHO (0x08)` for example.
+     */
+    GNL_VRPMDV_MCMD_C_MSG,
+
+    /**
+     * Provokes a NLMSG_ERR answer to this request as described in netlink manpage
+     * (https://man7.org/linux/man-pages/man7/netlink.7.html).
+     */
+    GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_C_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN (__GNL_VRPMDV_MCMD_C_MAX)
+/**
+ * The number of actual usable commands  in `enum GNL_FOOBAR_XMPL_COMMAND`.
+ * This is `GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_COUNT (GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN - 1)
+
+#define NODATARECEIVED 0
+#define DATARECEIVED 1
+
+
+
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex sendMTX;
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex receiveCV;
+    /**
+     * Wait Queue: if it is signaled we have received data from copro
+    */
+    wait_queue_head_t receive_queue;
+    /**
+     * Waitflag: 0= no data received, 1 = data received
+    */
+    int receive_queue_flag = NODATARECEIVED;
+
+    char* received_bytes = NULL;
+    int   received_len = 0;
+    //the rpmsg device which sends the data to the copro 
+    struct rpmsg_device* prpdev = NULL;	/* handle rpmsg device */    
+
+
+// Documentation is on the implementation of this function.
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_VRPMDV_OPS_LEN (GNL_VRPMDV_MCMD_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_vrpmdv_mcmd_ops[GNL_VRPMDV_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_VRPMDV_MCMD_C_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_vrpmdv_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = NULL, //gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = NULL, //gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = NULL, //gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_vrpmdv_mcmd_policy[GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_VRPMDV_MCMD_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_VRPMDV_MCMD_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_vrpmdv_mcmd_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_vrpmdv_mcmd_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_VRPMDV_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_vrpmdv_mcmd_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_VRPMDV_MCMD_C_MSG` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_vrpmdv_mcmd_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_VRPMDV_MCMD_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_VRPMDV_MCMD_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+    //aquire lock for cmd repmsg channel     
+    // std::lock sendlk(cmd_cb_progress_data.sendmtx);    
+
+    //send the message to the copro over RPMSG 
+    if (prpdev) {
+        rc = rpmsg_send(prpdev->ept, recv_msg, strlen(recv_msg));
+        if (rc) {
+            pr_err("rpmsg_send failed: %d\n", rc);
+            return rc;
+        }
+
+        // struct rpmsg_vrpmdv_mon_t *drv = dev_get_drvdata(&rpdev->dev);
+
+        // Send a message back after we receive the reply from rpmsg channel
+        // ---------------------
+
+        // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+        reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (reply_skb == NULL) {
+            pr_err("An error occurred in %s():\n", __func__);
+            return -ENOMEM;
+        }
+
+        // Create the message headersprpdev
+
+        // Add header to netlink message;
+        // afterwards the buffer looks like this:
+        // ----------------------------------
+        // | netlink header                 |
+        // | generic netlink header         |
+        // | <space for netlink attributes> |
+        // ----------------------------------
+        // msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+        //                        // According to my findings: this is not used for routing
+        //                        // This can be used in an application specific way to target
+        //                        // different endpoints within the same user application
+        //                        // but general rule: just put sender port id here
+        //                        info->snd_portid, // sending port (not process) id: int
+        //                        info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+        //                        &gnl_vrpmdv_mcmd_family, // struct genl_family *
+        //                        0, // flags for Netlink header: int; application specific and not mandatory
+        //                        // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+        //                        GNL_VRPMDV_MCMD_C_MSG
+        // );
+
+        msg_head = genlmsg_put_reply(reply_skb, // buffer for netlink message: struct sk_buff *
+                                    info, // info
+                                    &gnl_vrpmdv_mcmd_family, // struct genl_family *
+                                    0, // flags for Netlink header: int; application specific and not mandatory
+                                    // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                                    info->genlhdr->cmd
+        );
+
+        if (msg_head == NULL) {
+            rc = ENOMEM;
+            pr_err("An error occurred in %s():\n", __func__);
+            return -rc;
+        }
+
+        {
+            pr_info("wait for response\n");
+            // wait until receive_queue_flag=1 , that means we have received data from Copro
+            wait_event_interruptible(receive_queue, receive_queue_flag != 0 );
+            
+            //Copy data
+            receive_queue_flag = NODATARECEIVED;
+
+
+
+            // std::unique_lock lk(cmd_cb_progress_data.receivemtx);
+            // if (myCondVar.wait_until(uLock, timePoint) == std::cv_status::timeout)
+            // {
+            //     dev_err(&cmd_cb_progress_data.rpdev, "rpmsg_send failed, timeout: \n");
+            //     return -1:
+            // }
+
+            //pr_info("get response: '%s'\n", recv_msg);
+            if (received_len > 0) {                
+                pr_info("received data from copro %s\n", received_bytes);                
+            }
+            else {
+                pr_err("don't received data from Copro \n");                
+            }
+
+        }
+
+        // Add a GNL_VRPMDV_MCMD_A_MSG attribute (actual value/payload to be sent)
+        // echo the value we just received
+        rc = nla_put_string(reply_skb, GNL_VRPMDV_MCMD_A_MSG, received_bytes);
+
+        if (rc != 0) {
+            pr_err("An error occurred in %s():\n", __func__);
+            //free the buffer
+            kfree(received_bytes);
+            received_bytes = NULL;
+            return -rc;
+        }
+
+        // Finalize the message:
+        // Corrects the netlink message header (length) to include the appended
+        // attributes. Only necessary if attributes have been added to the message.
+        genlmsg_end(reply_skb, msg_head);
+
+        // Send the message back
+        rc = genlmsg_reply(reply_skb, info);
+        // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+        // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+        kfree(received_bytes);
+        received_bytes = NULL;
+
+        if (rc != 0) {
+            pr_err("An error occurred in %s():\n", __func__);
+            return -rc;
+        }
+        return 0;
+    
+    }
+    pr_info("Device not set in Probe. Should not happen");
+    return -1;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+
+
+
+/**
+ * callback that is called after the copro send data
+ * we have to copy it in a buffer for the netlink and later send it back to the userland
+ * 
+*/
+static int vrpmdv_monitoring_cb(struct rpmsg_device *rpdev, void *data, int len,
+						void *priv, u32 src)
+{
+	int ret = 0;
+	// struct instance_data *idata = dev_get_drvdata(&rpdev->dev);
+
+	// dev_info(&rpdev->dev, "incoming msg %d (src: 0x%x)\n",
+	// 	 ++idata->rx_count, src);
+
+	print_hex_dump_debug(__func__, DUMP_PREFIX_NONE, 16, 1, data, len,
+			     true);
+   	if (len == 0) {
+		pr_err("(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+    else {
+        pr_info("received logging: %s\n", (char*) data);                
+    }
+    
+	ret = rpmsg_send(rpdev->ept, retok, sizeof(retok));
+    
+    // received_bytes = (char *)kmalloc(len+1, GFP_KERNEL);
+	// memcpy(received_bytes, data, len);
+
+    // rpmsg_RxBuf[len] = 0;
+
+
+
+    // received_bytes = (char *)kmalloc(len, GFP_KERNEL);
+	// memcpy(received_bytes, data, len);    
+    // received_len = len;
+    // receive_queue_flag= DATARECEIVED;
+    // wake_up_interruptible(&receive_queue);
+
+	// /* samples should not live forever */
+	// if (idata->rx_count >= count) {
+	// 	dev_info(&rpdev->dev, "goodbye!\n");
+	// 	return 0;
+	// }
+
+	/* send a new message now */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret)
+	// 	dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+
+	return ret;
+}
+
+static int vrpmdv_mon_log_probe(struct rpmsg_device *rpdev)
+{
+    //int rc;	
+
+	// int ret;
+	// struct instance_data *idata;
+
+	// dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+	// 				rpdev->src, rpdev->dst);
+
+    pr_info("RPMSG mon logger device driver started.\n");
+
+	// idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	// if (!idata)
+	// 	return -ENOMEM;
+
+	// dev_set_drvdata(&rpdev->dev, idata);
+
+	// /* send a message to our remote processor to */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret) {
+	// 	dev_err(&rpdev->dev, "vrpmdv_monitoring_controler_send failed: %d\n", ret);
+	// 	return ret;
+	// }
+
+	// return 0;
+
+	// struct device *dev;
+    // dev = &rpdev->dev;
+	// struct rpmsg_vrpmdv_mon_t *rpmsg_vrpmdv_mon;
+
+	// rpmsg_vrpmdv_mon = devm_kzalloc(dev, sizeof(*rpmsg_vrpmdv_mon), GFP_KERNEL);
+	// if (!rpmsg_vrpmdv_mon)
+	// 	return -ENOMEM;
+
+    // mutex_init(&sendMTX);
+    // init_waitqueue_head (&receive_queue);    
+	prpdev = rpdev;
+
+	// dev_set_drvdata(&rpdev->dev, rpmsg_vrpmdv_mon);
+    pr_info("RPMSG Logger Device set.\n");
+
+
+	/** NEU **/
+    // if (cmd_cb_progress_data.rpdev == NULL) {
+     // cmd_cb_progress_data.rpdev = rpdev;
+     // pr_info("RPMSG CMD Device set.\n");
+    // }
+    // else {
+    //     pr_info("Error: RPMSG CMD Device already set. Don't set it twice\n");        
+    // }
+
+    //pr_info("Generic Netlink VRPMDV-Mon-Log Module started.\n");
+
+    // Register family with its operations and policies
+    // rc = genl_register_family(&gnl_vrpmdv_mcmd_family);
+    // if (rc != 0) {
+    //     pr_err("FAILED: genl_register_family(): %i\n", rc);
+    //     pr_err("An error occurred while inserting the generic netlink example module\n");
+    //     return -1;
+    // } else {
+    //     pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    // }
+
+    return 0;
+
+
+
+}
+
+static void vrpmdv_mon_log_remove(struct rpmsg_device *rpdev)
+{
+    //int ret;
+    pr_info("Mon Logger unloaded.\n");
+
+    // Unregister the family
+    // ret = genl_unregister_family(&gnl_vrpmdv_mcmd_family);
+    // if (ret != 0) {
+    //     pr_err("genl_unregister_family() failed: %i\n", ret);
+    //     return;
+    // } else {
+    //     pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    // }
+
+    // mutex_destroy(&sendMTX);
+    // wake_up_interruptible(&receive_queue);
+
+	pr_info("vrpmdv-mon logger driver is removed\n");	
+	// dev_info(&rpdev->dev, "vrpmdv-monitoring controler driver is removed\n");
+
+}
+
+static struct rpmsg_device_id vrpmdv_mon_log_id_table[] = {
+	{ .name	= "vrpmdv-mon-log" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, vrpmdv_mon_log_id_table);
+
+static struct rpmsg_driver vrpmdv_mon_log = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= vrpmdv_mon_log_id_table,
+	.probe		= vrpmdv_mon_log_probe,
+	.callback	= vrpmdv_mon_log_cb,
+	.remove		= vrpmdv_mon_log_remove,
+};
+module_rpmsg_driver(vrpmdv_mon_log);
+
+
+// static struct rpmsg_driver vrpmdv_monitoring_data = {
+// 	.drv.name	= KBUILD_MODNAME,
+// 	.id_table	= vrpmdv_monitoring_controler_id_table,
+// 	.probe		= vrpmdv_monitoring_probe,
+// 	.callback	= vrpmdv_monitoring_cb,
+// 	.remove		= vrpmdv_monitoring_remove,
+// };
+
+// module_rpmsg_driver(vrpmdv_monitoring_data);
+
+MODULE_DESCRIPTION("Remote processor messaging vrpmdv monitoring controler");
+MODULE_LICENSE("GPL v2");
+
+
+
+// /**
+//  * Module/driver initializer. Called on module load/insertion.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static int __init gnl_foobar_xmpl_module_init(void) {
+//     int rc;
+//     pr_info("Generic Netlink Example Module inserted.\n");
+
+//     // Register family with its operations and policies
+//     rc = genl_register_family(&gnl_foobar_xmpl_family);
+//     if (rc != 0) {
+//         pr_err("FAILED: genl_register_family(): %i\n", rc);
+//         pr_err("An error occurred while inserting the generic netlink example module\n");
+//         return -1;
+//     } else {
+//         pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_init(&dumpit_cb_progress_data.mtx);
+
+//     return 0;
+// }
+
+// /**
+//  * Module/driver uninitializer. Called on module unload/removal.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static void __exit gnl_foobar_xmpl_module_exit(void) {
+//     int ret;
+//     pr_info("Generic Netlink Example Module unloaded.\n");
+
+//     // Unregister the family
+//     ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+//     if (ret != 0) {
+//         pr_err("genl_unregister_family() failed: %i\n", ret);
+//         return;
+//     } else {
+//         pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_destroy(&dumpit_cb_progress_data.mtx);
+// }
+
+
+// ----
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/files/vrpmdv-mon-tty.c

@@ -0,0 +1,308 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 STMicroelectronics - All Rights Reserved
+ *
+ * The rpmsg tty driver implements serial communication on the RPMsg bus to makes
+ * possible for user-space programs to send and receive rpmsg messages as a standard
+ * tty protocol.
+ *
+ * The remote processor can instantiate a new tty by requesting a "rpmsg-tty" RPMsg service.
+ * The "rpmsg-tty" service is directly used for data exchange. No flow control is implemented yet.
+ */
+
+#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#define RPMSG_TTY_NAME	"ttyMON"
+#define MAX_TTY_RPMSG	32
+
+static DEFINE_IDR(tty_idr);	/* tty instance id */
+static DEFINE_MUTEX(idr_lock);	/* protects tty_idr */
+
+static struct tty_driver *rpmsg_tty_driver;
+
+struct rpmsg_tty_port {
+	struct tty_port		port;	 /* TTY port data */
+	int			id;	 /* TTY rpmsg index */
+	struct rpmsg_device	*rpdev;	 /* rpmsg device */
+};
+
+static int rpmsg_tty_cb(struct rpmsg_device *rpdev, void *data, int len, void *priv, u32 src)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+	int copied;
+
+	pr_info("%s() invoked\n", __func__);
+
+	if (!len)
+		return -EINVAL;
+
+	copied = tty_insert_flip_string(&cport->port, data, len);
+	pr_info("%s() received\n", data);
+	
+	if (copied != len)
+		dev_err_ratelimited(&rpdev->dev, "Trunc buffer: available space is %d\n", copied);
+		pr_info("%s() error cop\n", __func__);
+	
+	tty_flip_buffer_push(&cport->port);
+	pr_info("%s() invoked. succes!!\n", __func__);
+	return 0;
+}
+
+static int rpmsg_tty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+	pr_info("%s() invoked\n", __func__);
+	struct rpmsg_tty_port *cport = idr_find(&tty_idr, tty->index);
+	struct tty_port *port;
+
+	tty->driver_data = cport;
+
+	port = tty_port_get(&cport->port);
+	return tty_port_install(port, driver, tty);
+}
+
+static void rpmsg_tty_cleanup(struct tty_struct *tty)
+{
+	pr_info("%s() invoked\n", __func__);	
+	tty_port_put(tty->port);
+}
+
+static int rpmsg_tty_open(struct tty_struct *tty, struct file *filp)
+{
+	pr_info("%s() invoked\n", __func__);
+	return tty_port_open(tty->port, tty, filp);
+}
+
+static void rpmsg_tty_close(struct tty_struct *tty, struct file *filp)
+{
+	pr_info("%s() invoked\n", __func__);
+	return tty_port_close(tty->port, tty, filp);
+}
+
+static int rpmsg_tty_write(struct tty_struct *tty, const u8 *buf, int len)
+{
+	pr_info("%s() invoked\n", __func__);
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	struct rpmsg_device *rpdev;
+	int msg_max_size, msg_size;
+	int ret;
+
+	rpdev = cport->rpdev;
+
+	msg_max_size = rpmsg_get_mtu(rpdev->ept);
+	if (msg_max_size < 0)
+		return msg_max_size;
+
+	msg_size = min(len, msg_max_size);
+
+	/*
+	 * Use rpmsg_trysend instead of rpmsg_send to send the message so the caller is not
+	 * hung until a rpmsg buffer is available. In such case rpmsg_trysend returns -ENOMEM.
+	 */
+	ret = rpmsg_trysend(rpdev->ept, (void *)buf, msg_size);
+	if (ret) {
+		dev_dbg_ratelimited(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+	pr_info("%s() invoked. send succes!!\n", __func__);
+	return msg_size;
+}
+
+static unsigned int rpmsg_tty_write_room(struct tty_struct *tty)
+{
+	pr_info("%s() invoked\n", __func__);
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	int size;
+
+	size = rpmsg_get_mtu(cport->rpdev->ept);
+	if (size < 0)
+		return 0;
+	pr_info("%s() invoked. write success\n", __func__);
+	return size;
+}
+
+static void rpmsg_tty_hangup(struct tty_struct *tty)
+{
+	pr_info("%s() invoked\n", __func__);
+	tty_port_hangup(tty->port);
+}
+
+static const struct tty_operations rpmsg_tty_ops = {
+	.install	= rpmsg_tty_install,
+	.open		= rpmsg_tty_open,
+	.close		= rpmsg_tty_close,
+	.write		= rpmsg_tty_write,
+	.write_room	= rpmsg_tty_write_room,
+	.hangup		= rpmsg_tty_hangup,
+	.cleanup	= rpmsg_tty_cleanup,
+};
+
+static struct rpmsg_tty_port *rpmsg_tty_alloc_cport(void)
+{
+	pr_info("%s() invoked\n", __func__);	
+	struct rpmsg_tty_port *cport;
+	int ret;
+
+	cport = kzalloc(sizeof(*cport), GFP_KERNEL);
+	if (!cport)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_lock(&idr_lock);
+	ret = idr_alloc(&tty_idr, cport, 0, MAX_TTY_RPMSG, GFP_KERNEL);
+	mutex_unlock(&idr_lock);
+
+	if (ret < 0) {
+		kfree(cport);
+		return ERR_PTR(ret);
+	}
+
+	cport->id = ret;
+
+	return cport;
+}
+
+static void rpmsg_tty_destruct_port(struct tty_port *port)
+{
+	pr_info("%s() invoked\n", __func__);	
+	struct rpmsg_tty_port *cport = container_of(port, struct rpmsg_tty_port, port);
+
+	mutex_lock(&idr_lock);
+	idr_remove(&tty_idr, cport->id);
+	mutex_unlock(&idr_lock);
+
+	kfree(cport);
+}
+
+static const struct tty_port_operations rpmsg_tty_port_ops = {
+	.destruct = rpmsg_tty_destruct_port,
+};
+
+
+static int rpmsg_tty_probe(struct rpmsg_device *rpdev)
+{
+	pr_info("%s() invoked\n", __func__);
+	struct rpmsg_tty_port *cport;
+	struct device *dev = &rpdev->dev;
+	struct device *tty_dev;
+	int ret;
+
+	cport = rpmsg_tty_alloc_cport();
+	if (IS_ERR(cport))
+		return dev_err_probe(dev, PTR_ERR(cport), "Failed to alloc tty mon port\n");
+
+	tty_port_init(&cport->port);
+	cport->port.ops = &rpmsg_tty_port_ops;
+
+	tty_dev = tty_port_register_device(&cport->port, rpmsg_tty_driver,
+					   cport->id, dev);
+	if (IS_ERR(tty_dev)) {
+		ret = dev_err_probe(dev, PTR_ERR(tty_dev), "Failed to register tty mon port\n");
+		tty_port_put(&cport->port);
+		return ret;
+	}
+
+	cport->rpdev = rpdev;
+
+	dev_set_drvdata(dev, cport);
+
+	dev_dbg(dev, "New channel: 0x%x -> 0x%x: " RPMSG_TTY_NAME "%d\n",
+		rpdev->src, rpdev->dst, cport->id);
+
+	return 0;
+}
+
+static void rpmsg_tty_remove(struct rpmsg_device *rpdev)
+{
+	pr_info("%s() invoked\n", __func__);
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+
+	dev_dbg(&rpdev->dev, "Removing mon tty device %d\n", cport->id);
+
+	/* User hang up to release the tty */
+	tty_port_tty_hangup(&cport->port, false);
+
+	tty_unregister_device(rpmsg_tty_driver, cport->id);
+
+	tty_port_put(&cport->port);
+}
+
+static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = {
+	{ .name	= "vrpmdv-mon-tty" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table);
+
+static struct rpmsg_driver rpmsg_tty_rpmsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= rpmsg_driver_tty_id_table,
+	.probe		= rpmsg_tty_probe,
+	.callback	= rpmsg_tty_cb,
+	.remove		= rpmsg_tty_remove,
+};
+
+static int __init rpmsg_tty_init(void)
+{
+	pr_info("%s() invoked\n", __func__);
+	int ret;
+
+	rpmsg_tty_driver = tty_alloc_driver(MAX_TTY_RPMSG, TTY_DRIVER_REAL_RAW |
+					    TTY_DRIVER_DYNAMIC_DEV);
+	if (IS_ERR(rpmsg_tty_driver))
+		return PTR_ERR(rpmsg_tty_driver);
+
+	rpmsg_tty_driver->driver_name = "vrpmdv-mon-tty";
+	rpmsg_tty_driver->name = RPMSG_TTY_NAME;
+	rpmsg_tty_driver->major = 0;
+	rpmsg_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
+
+	/* Disable unused mode by default */
+	rpmsg_tty_driver->init_termios = tty_std_termios;
+	rpmsg_tty_driver->init_termios.c_lflag &= ~(ECHO | ICANON);
+	rpmsg_tty_driver->init_termios.c_oflag &= ~(OPOST | ONLCR);
+
+	tty_set_operations(rpmsg_tty_driver, &rpmsg_tty_ops);
+
+	ret = tty_register_driver(rpmsg_tty_driver);
+	if (ret < 0) {
+		pr_err("Couldn't install mon tty driver: %d\n", ret);
+		goto error_put;
+	}
+
+	ret = register_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	if (ret < 0) {
+		pr_err("Couldn't register mon tty driver: %d\n", ret);
+		goto error_unregister;
+	}
+	pr_info("%s() invoked. Install complete!\n", __func__);
+	return 0;
+
+error_unregister:
+	pr_info("%s() invoked unregister.\n", __func__);
+	tty_unregister_driver(rpmsg_tty_driver);
+
+error_put:
+	pr_info("%s() invoked. error put\n", __func__);
+	tty_driver_kref_put(rpmsg_tty_driver);
+
+	return ret;
+}
+
+static void __exit rpmsg_tty_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	tty_unregister_driver(rpmsg_tty_driver);
+	tty_driver_kref_put(rpmsg_tty_driver);
+	idr_destroy(&tty_idr);
+}
+
+module_init(rpmsg_tty_init);
+module_exit(rpmsg_tty_exit);
+
+MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>");
+MODULE_DESCRIPTION("remote processor messaging tty driver");
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/files/vrpmdv_mon_tty.c.old

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 STMicroelectronics - All Rights Reserved
+ *
+ * The rpmsg tty driver implements serial communication on the RPMsg bus to makes
+ * possible for user-space programs to send and receive rpmsg messages as a standard
+ * tty protocol.
+ *
+ * The remote processor can instantiate a new tty by requesting a "rpmsg-tty" RPMsg service.
+ * The "rpmsg-tty" service is directly used for data exchange. No flow control is implemented yet.
+ */
+
+#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#define RPMSG_TTY_NAME	"ttyMON"
+#define MAX_TTY_RPMSG	32
+
+static DEFINE_IDR(tty_idr);	/* tty instance id */
+static DEFINE_MUTEX(idr_lock);	/* protects tty_idr */
+
+static struct tty_driver *rpmsg_tty_driver;
+
+struct rpmsg_tty_port {
+	struct tty_port		port;	 /* TTY port data */
+	int			id;	 /* TTY rpmsg index */
+	struct rpmsg_device	*rpdev;	 /* rpmsg device */
+};
+
+static int rpmsg_tty_cb(struct rpmsg_device *rpdev, void *data, int len, void *priv, u32 src)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+	int copied;
+
+	if (!len)
+		return -EINVAL;
+	copied = tty_insert_flip_string(&cport->port, data, len);
+	if (copied != len)
+		dev_err_ratelimited(&rpdev->dev, "Trunc buffer: available space is %d\n", copied);
+	tty_flip_buffer_push(&cport->port);
+
+	return 0;
+}
+
+static int rpmsg_tty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = idr_find(&tty_idr, tty->index);
+	struct tty_port *port;
+
+	tty->driver_data = cport;
+
+	port = tty_port_get(&cport->port);
+	return tty_port_install(port, driver, tty);
+}
+
+static void rpmsg_tty_cleanup(struct tty_struct *tty)
+{
+	tty_port_put(tty->port);
+}
+
+static int rpmsg_tty_open(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_open(tty->port, tty, filp);
+}
+
+static void rpmsg_tty_close(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_close(tty->port, tty, filp);
+}
+
+static int rpmsg_tty_write(struct tty_struct *tty, const u8 *buf, int len)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	struct rpmsg_device *rpdev;
+	int msg_max_size, msg_size;
+	int ret;
+
+	rpdev = cport->rpdev;
+
+	msg_max_size = rpmsg_get_mtu(rpdev->ept);
+	if (msg_max_size < 0)
+		return msg_max_size;
+
+	msg_size = min(len, msg_max_size);
+
+	/*
+	 * Use rpmsg_trysend instead of rpmsg_send to send the message so the caller is not
+	 * hung until a rpmsg buffer is available. In such case rpmsg_trysend returns -ENOMEM.
+	 */
+	ret = rpmsg_trysend(rpdev->ept, (void *)buf, msg_size);
+	if (ret) {
+		dev_dbg_ratelimited(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return msg_size;
+}
+
+static unsigned int rpmsg_tty_write_room(struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	int size;
+
+	size = rpmsg_get_mtu(cport->rpdev->ept);
+	if (size < 0)
+		return 0;
+
+	return size;
+}
+
+static void rpmsg_tty_hangup(struct tty_struct *tty)
+{
+	tty_port_hangup(tty->port);
+}
+
+static const struct tty_operations rpmsg_tty_ops = {
+	.install	= rpmsg_tty_install,
+	.open		= rpmsg_tty_open,
+	.close		= rpmsg_tty_close,
+	.write		= rpmsg_tty_write,
+	.write_room	= rpmsg_tty_write_room,
+	.hangup		= rpmsg_tty_hangup,
+	.cleanup	= rpmsg_tty_cleanup,
+};
+
+static struct rpmsg_tty_port *rpmsg_tty_alloc_cport(void)
+{
+	struct rpmsg_tty_port *cport;
+	int ret;
+
+	cport = kzalloc(sizeof(*cport), GFP_KERNEL);
+	if (!cport)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_lock(&idr_lock);
+	ret = idr_alloc(&tty_idr, cport, 0, MAX_TTY_RPMSG, GFP_KERNEL);
+	mutex_unlock(&idr_lock);
+
+	if (ret < 0) {
+		kfree(cport);
+		return ERR_PTR(ret);
+	}
+
+	cport->id = ret;
+
+	return cport;
+}
+
+static void rpmsg_tty_destruct_port(struct tty_port *port)
+{
+	struct rpmsg_tty_port *cport = container_of(port, struct rpmsg_tty_port, port);
+
+	mutex_lock(&idr_lock);
+	idr_remove(&tty_idr, cport->id);
+	mutex_unlock(&idr_lock);
+
+	kfree(cport);
+}
+
+static const struct tty_port_operations rpmsg_tty_port_ops = {
+	.destruct = rpmsg_tty_destruct_port,
+};
+
+
+static int rpmsg_tty_probe(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport;
+	struct device *dev = &rpdev->dev;
+	struct device *tty_dev;
+	int ret;
+
+	cport = rpmsg_tty_alloc_cport();
+	if (IS_ERR(cport))
+		return dev_err_probe(dev, PTR_ERR(cport), "Failed to alloc tty mon port\n");
+
+	tty_port_init(&cport->port);
+	cport->port.ops = &rpmsg_tty_port_ops;
+
+	tty_dev = tty_port_register_device(&cport->port, rpmsg_tty_driver,
+					   cport->id, dev);
+	if (IS_ERR(tty_dev)) {
+		ret = dev_err_probe(dev, PTR_ERR(tty_dev), "Failed to register tty mon port\n");
+		tty_port_put(&cport->port);
+		return ret;
+	}
+
+	cport->rpdev = rpdev;
+
+	dev_set_drvdata(dev, cport);
+
+	dev_dbg(dev, "New channel: 0x%x -> 0x%x: " RPMSG_TTY_NAME "%d\n",
+		rpdev->src, rpdev->dst, cport->id);
+
+	return 0;
+}
+
+static void rpmsg_tty_remove(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+
+	dev_dbg(&rpdev->dev, "Removing mon tty device %d\n", cport->id);
+
+	/* User hang up to release the tty */
+	tty_port_tty_hangup(&cport->port, false);
+
+	tty_unregister_device(rpmsg_tty_driver, cport->id);
+
+	tty_port_put(&cport->port);
+}
+
+static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = {
+	{ .name	= "vrpmdv-mon-tty" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table);
+
+static struct rpmsg_driver rpmsg_tty_rpmsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= rpmsg_driver_tty_id_table,
+	.probe		= rpmsg_tty_probe,
+	.callback	= rpmsg_tty_cb,
+	.remove		= rpmsg_tty_remove,
+};
+
+static int __init rpmsg_tty_init(void)
+{
+	int ret;
+
+	rpmsg_tty_driver = tty_alloc_driver(MAX_TTY_RPMSG, TTY_DRIVER_REAL_RAW |
+					    TTY_DRIVER_DYNAMIC_DEV);
+	if (IS_ERR(rpmsg_tty_driver))
+		return PTR_ERR(rpmsg_tty_driver);
+
+	rpmsg_tty_driver->driver_name = "vrpmdv-mon-tty";
+	rpmsg_tty_driver->name = RPMSG_TTY_NAME;
+	rpmsg_tty_driver->major = 0;
+	rpmsg_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
+
+	/* Disable unused mode by default */
+	rpmsg_tty_driver->init_termios = tty_std_termios;
+	rpmsg_tty_driver->init_termios.c_lflag &= ~(ECHO | ICANON);
+	rpmsg_tty_driver->init_termios.c_oflag &= ~(OPOST | ONLCR);
+
+	tty_set_operations(rpmsg_tty_driver, &rpmsg_tty_ops);
+
+	ret = tty_register_driver(rpmsg_tty_driver);
+	if (ret < 0) {
+		pr_err("Couldn't install mon tty driver: %d\n", ret);
+		goto error_put;
+	}
+
+	ret = register_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	if (ret < 0) {
+		pr_err("Couldn't register mon tty driver: %d\n", ret);
+		goto error_unregister;
+	}
+
+	return 0;
+
+error_unregister:
+	tty_unregister_driver(rpmsg_tty_driver);
+
+error_put:
+	tty_driver_kref_put(rpmsg_tty_driver);
+
+	return ret;
+}
+
+static void __exit rpmsg_tty_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	tty_unregister_driver(rpmsg_tty_driver);
+	tty_driver_kref_put(rpmsg_tty_driver);
+	idr_destroy(&tty_idr);
+}
+
+module_init(rpmsg_tty_init);
+module_exit(rpmsg_tty_exit);
+
+MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>");
+MODULE_DESCRIPTION("remote processor messaging tty driver");
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/kernel-module-vrpmdv-monitoring-driver.bb

@@ -0,0 +1,16 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/netlink-save.c.save

@@ -0,0 +1,541 @@
+/* Copyright 2021 Philipp Schuster
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of 
+ * this software and associated documentation files (the "Software"), to deal in the 
+ * Software without restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies
+ * or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "gnl_foobar_xmpl" which shows you the basics of using
+ * Generic Netlink in the kernel. It registers a Netlink family called "gnl_foobar_xmpl". See
+ * "gnl_foobar_xmpl_prop.h" for common properties of the family. "Generic Netlink" offers us a lot of
+ * convenient functions to register new/custom Netlink families on the fly during runtime. We use this
+ * functionality here. It implements simple IPC between Userland and Kernel (Kernel responds to userland).
+ *
+ * Check "gnl_foobar_xmpl_prop.h" for common properties of the family first, afterwards follow the code here.
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+#include "gnl_foobar_xmpl_prop.h"
+
+// Module/Driver description.
+// You can see this for example when executing `$ modinfo ./gnl_foobar_xmpl.ko` (after build).
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Philipp Schuster <phip1611@gmail.com>");
+MODULE_DESCRIPTION(
+        "Linux driver that registers the custom Netlink family "
+        "\"" FAMILY_NAME "\" via Generic Netlink and responds to echo messages "
+                         "according to the properties specified in \"gnl_foobar_xmpl_prop.h\"."
+);
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+/**
+ * Data structure required for our .dumpit callback handler to
+ * know about the progress of an ongoing dump.
+ * See the dumpit callback handler how it is used.
+ */
+struct {
+    // from <linux/mutex.h>
+    /**
+     * Only one process is allowed per dump process. We need a lock for that.
+     */
+    struct mutex mtx;
+    /**
+     * Number that describes how many packets we need to send until we are done
+     * during an ongoing dumpit process. 0 = done.
+     */
+    int unsigned runs_to_go;
+    /**
+     * Number that describes how many packets per dump are sent in total.
+     * Constant per dump.
+     */
+    int unsigned total_runs;
+} dumpit_cb_progress_data;
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_FOOBAR_OPS_LEN (GNL_FOOBAR_XMPL_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_foobar_xmpl_ops[GNL_FOOBAR_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_FOOBAR_XMPL_C_ECHO_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_echo_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_foobar_xmpl_policy[GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_FOOBAR_XMPL_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_FOOBAR_XMPL_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_foobar_xmpl_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_foobar_xmpl_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_FOOBAR_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_foobar_xmpl_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_ECHO` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_FOOBAR_XMPL_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_FOOBAR_XMPL_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+
+    // Send a message back
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+                           // According to my findings: this is not used for routing
+                           // This can be used in an application specific way to target
+                           // different endpoints within the same user application
+                           // but general rule: just put sender port id here
+                           info->snd_portid, // sending port (not process) id: int
+                           info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags for Netlink header: int; application specific and not mandatory
+                           // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG
+    );
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_FOOBAR_XMPL_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_FOOBAR_XMPL_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/**
+ * ".dumpit"-callback function if a Generic Netlink with command ECHO_MSG and flag `NLM_F_DUMP` is received.
+ * Please look into the comments where this is used as ".dumpit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".dumpit" callbacks.
+ *
+ * A dump must be understand of "give me all data of a given entity"
+ * rather than a "dump of the netlink message itself" for debugging etc!
+ *
+ * This handler requires `gnl_cb_echo_dumpit_before` to run before a dump and `gnl_cb_echo_dumpit_after` after a dump.
+ *
+ * For the sake of simplicity, we use the ECHO_MSG command for the dump. In fact, we don't expect a
+ * MSG-Attribute here, unlike the regular ECHO_MSG handler. We reply with a dump of
+ * "all messages that we got" (application specific, hard coded in this example).
+*/
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb) {
+    void *msg_head;
+    int ret;
+    static const char HELLO_FROM_DUMPIT_MSG[] = "You set the flag NLM_F_DUMP; this message is "
+                                                "brought to you by .dumpit callback :)";
+    pr_info("Called %s()\n", __func__);
+
+    if (dumpit_cb_progress_data.runs_to_go == 0) {
+        pr_info("no more data to send in dumpit cb\n");
+        // mark that dump is done;
+        return 0;
+    } else {
+        dumpit_cb_progress_data.runs_to_go--;
+        pr_info("%s: %d more runs to do\n", __func__, dumpit_cb_progress_data.runs_to_go);
+    }
+
+    msg_head = genlmsg_put(pre_allocated_skb, // buffer for netlink message: struct sk_buff *
+            // According to my findings: this is not used for routing
+            // This can be used in an application specific way to target
+            // different endpoints within the same user application
+            // but general rule: just put sender port id here
+                           cb->nlh->nlmsg_pid, // sending port (not process) id: int
+            // sequence number: int (might be used by receiver, but not mandatory)
+            // sequence 0, 1, 2...
+                           dumpit_cb_progress_data.total_runs - dumpit_cb_progress_data.runs_to_go - 1,
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags: int (for netlink header); we don't check them in the userland; application specific
+            // this way we can trigger a specific command/callback on the receiving side or imply
+            // on which type of command we are currently answering; this is application specific
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG // cmd: u8 (for generic netlink header);
+    );
+    if (msg_head == NULL) {
+        pr_info("An error occurred in %s(): genlmsg_put() failed\n", __func__);
+        return -ENOMEM;
+    }
+    ret = nla_put_string(
+            pre_allocated_skb,
+            GNL_FOOBAR_XMPL_A_MSG,
+            HELLO_FROM_DUMPIT_MSG
+    );
+    if (ret < 0) {
+        pr_info("An error occurred in %s():\n", __func__);
+        return ret;
+    }
+    genlmsg_end(pre_allocated_skb, msg_head);
+
+    // return the length of data we wrote into the pre-allocated buffer
+    return pre_allocated_skb->len;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before(struct netlink_callback *cb) {
+    int ret;
+    static int unsigned const dump_runs = 3;
+    pr_info("%s: dump started. acquire lock. initialize dump runs_to_go (number of receives userland can make) to %d runs\n", __func__, dump_runs);
+    // Lock the mutex like mutex_lock(), and return 0 if the mutex has been acquired or sleep until the mutex becomes available
+    // If a signal arrives while waiting for the lock then this function returns -EINTR.
+    ret = mutex_lock_interruptible(&dumpit_cb_progress_data.mtx);
+    if (ret != 0) {
+        pr_err("Failed to get lock!\n");
+        return ret;
+    }
+    dumpit_cb_progress_data.total_runs = dump_runs;
+    dumpit_cb_progress_data.runs_to_go = dump_runs;
+    return 0;
+
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb) {
+    pr_info("%s: dump done. release lock\n", __func__);
+    mutex_unlock(&dumpit_cb_progress_data.mtx);
+    return 0;
+}
+
+/**
+ * Module/driver initializer. Called on module load/insertion.
+ *
+ * @return success (0) or error code.
+ */
+static int __init gnl_foobar_xmpl_module_init(void) {
+    int rc;
+    pr_info("Generic Netlink Example Module inserted.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_foobar_xmpl_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_init(&dumpit_cb_progress_data.mtx);
+
+    return 0;
+}
+
+/**
+ * Module/driver uninitializer. Called on module unload/removal.
+ *
+ * @return success (0) or error code.
+ */
+static void __exit gnl_foobar_xmpl_module_exit(void) {
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&dumpit_cb_progress_data.mtx);
+}
+
+module_init(gnl_foobar_xmpl_module_init);
+module_exit(gnl_foobar_xmpl_module_exit);

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/rpmsg_sdb.csva

@@ -0,0 +1,536 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) STMicroelectronics 2019 - All Rights Reserved
+ * Author: Jean-Philippe Romain <jean-philippe.romain@st.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+
+#define RPMSG_SDB_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "stm32-rpmsg-sdb";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_debug("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+
+	pr_debug("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+
+	/* Get first part containing the buffer id */
+	sub_str = strsep(&rxbuf_str, delimiter);
+
+	pr_debug("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+	/* Save Buffer id and size: template BxLyyyyyyyy*/
+	ret = kstrtol(&sub_str[1], 10, &bufid);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+		goto out;
+	}
+
+	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+		goto out;
+	}
+
+	*size = (size_t)bsize;
+	*buffer_id = (int)bufid;
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_buffer_size(_rpdev->ept);
+
+	if (msg_size < 0)
+		return msg_size;
+
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			return ret;
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+		if (!_buffer->vaddr) {
+			pr_err("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_debug("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot))
+			return -EAGAIN;
+
+		_buffer->uaddr = (void *)vma->vm_start;
+
+		/* Send information to remote proc */
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_debug("rpmsg_sdb(%s): Free the CMA allocation: pos->size:%08x, pos->vaddr:%08x, pos->paddr:%08x\n",
+					__func__,
+					pos->size,
+					pos->vaddr,
+					pos->paddr);
+
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,
+					pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+    //dev_err(rpmsg_sdb_dev, "(%s) lenght: %d\n", __func__,len);
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+		/* TODO: quid if nothing find during the loop ? */
+	}
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "rpmsg-sdb-channel" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+static int __init rpmsg_sdb_drv_init(void)
+{
+	int ret = 0;
+
+	/* Register rpmsg device */
+	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+	if (ret) {
+		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+		return ret;
+	}
+
+	pr_info("rpmsg_sdb: Init done\n");
+
+	return ret;
+}
+
+static void __exit rpmsg_sdb_drv_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+	pr_info("rpmsg_sdb: Exit\n");
+}
+
+module_init(rpmsg_sdb_drv_init);
+module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Jean-Philippe Romain <jean-philippe.romain@st.com>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/ttyrpmsg.csave

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 STMicroelectronics - All Rights Reserved
+ *
+ * The rpmsg tty driver implements serial communication on the RPMsg bus to makes
+ * possible for user-space programs to send and receive rpmsg messages as a standard
+ * tty protocol.
+ *
+ * The remote processor can instantiate a new tty by requesting a "rpmsg-tty" RPMsg service.
+ * The "rpmsg-tty" service is directly used for data exchange. No flow control is implemented yet.
+ */
+
+#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#define RPMSG_TTY_NAME	"ttyRPMSG"
+#define MAX_TTY_RPMSG	32
+
+static DEFINE_IDR(tty_idr);	/* tty instance id */
+static DEFINE_MUTEX(idr_lock);	/* protects tty_idr */
+
+static struct tty_driver *rpmsg_tty_driver;
+
+struct rpmsg_tty_port {
+	struct tty_port		port;	 /* TTY port data */
+	int			id;	 /* TTY rpmsg index */
+	struct rpmsg_device	*rpdev;	 /* rpmsg device */
+};
+
+static int rpmsg_tty_cb(struct rpmsg_device *rpdev, void *data, int len, void *priv, u32 src)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+	int copied;
+
+	if (!len)
+		return -EINVAL;
+	copied = tty_insert_flip_string(&cport->port, data, len);
+	if (copied != len)
+		dev_err_ratelimited(&rpdev->dev, "Trunc buffer: available space is %d\n", copied);
+	tty_flip_buffer_push(&cport->port);
+
+	return 0;
+}
+
+static int rpmsg_tty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = idr_find(&tty_idr, tty->index);
+	struct tty_port *port;
+
+	tty->driver_data = cport;
+
+	port = tty_port_get(&cport->port);
+	return tty_port_install(port, driver, tty);
+}
+
+static void rpmsg_tty_cleanup(struct tty_struct *tty)
+{
+	tty_port_put(tty->port);
+}
+
+static int rpmsg_tty_open(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_open(tty->port, tty, filp);
+}
+
+static void rpmsg_tty_close(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_close(tty->port, tty, filp);
+}
+
+static int rpmsg_tty_write(struct tty_struct *tty, const u8 *buf, int len)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	struct rpmsg_device *rpdev;
+	int msg_max_size, msg_size;
+	int ret;
+
+	rpdev = cport->rpdev;
+
+	msg_max_size = rpmsg_get_mtu(rpdev->ept);
+	if (msg_max_size < 0)
+		return msg_max_size;
+
+	msg_size = min(len, msg_max_size);
+
+	/*
+	 * Use rpmsg_trysend instead of rpmsg_send to send the message so the caller is not
+	 * hung until a rpmsg buffer is available. In such case rpmsg_trysend returns -ENOMEM.
+	 */
+	ret = rpmsg_trysend(rpdev->ept, (void *)buf, msg_size);
+	if (ret) {
+		dev_dbg_ratelimited(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return msg_size;
+}
+
+static unsigned int rpmsg_tty_write_room(struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	int size;
+
+	size = rpmsg_get_mtu(cport->rpdev->ept);
+	if (size < 0)
+		return 0;
+
+	return size;
+}
+
+static void rpmsg_tty_hangup(struct tty_struct *tty)
+{
+	tty_port_hangup(tty->port);
+}
+
+static const struct tty_operations rpmsg_tty_ops = {
+	.install	= rpmsg_tty_install,
+	.open		= rpmsg_tty_open,
+	.close		= rpmsg_tty_close,
+	.write		= rpmsg_tty_write,
+	.write_room	= rpmsg_tty_write_room,
+	.hangup		= rpmsg_tty_hangup,
+	.cleanup	= rpmsg_tty_cleanup,
+};
+
+static struct rpmsg_tty_port *rpmsg_tty_alloc_cport(void)
+{
+	struct rpmsg_tty_port *cport;
+	int ret;
+
+	cport = kzalloc(sizeof(*cport), GFP_KERNEL);
+	if (!cport)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_lock(&idr_lock);
+	ret = idr_alloc(&tty_idr, cport, 0, MAX_TTY_RPMSG, GFP_KERNEL);
+	mutex_unlock(&idr_lock);
+
+	if (ret < 0) {
+		kfree(cport);
+		return ERR_PTR(ret);
+	}
+
+	cport->id = ret;
+
+	return cport;
+}
+
+static void rpmsg_tty_destruct_port(struct tty_port *port)
+{
+	struct rpmsg_tty_port *cport = container_of(port, struct rpmsg_tty_port, port);
+
+	mutex_lock(&idr_lock);
+	idr_remove(&tty_idr, cport->id);
+	mutex_unlock(&idr_lock);
+
+	kfree(cport);
+}
+
+static const struct tty_port_operations rpmsg_tty_port_ops = {
+	.destruct = rpmsg_tty_destruct_port,
+};
+
+
+static int rpmsg_tty_probe(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport;
+	struct device *dev = &rpdev->dev;
+	struct device *tty_dev;
+	int ret;
+
+	cport = rpmsg_tty_alloc_cport();
+	if (IS_ERR(cport))
+		return dev_err_probe(dev, PTR_ERR(cport), "Failed to alloc tty port\n");
+
+	tty_port_init(&cport->port);
+	cport->port.ops = &rpmsg_tty_port_ops;
+
+	tty_dev = tty_port_register_device(&cport->port, rpmsg_tty_driver,
+					   cport->id, dev);
+	if (IS_ERR(tty_dev)) {
+		ret = dev_err_probe(dev, PTR_ERR(tty_dev), "Failed to register tty port\n");
+		tty_port_put(&cport->port);
+		return ret;
+	}
+
+	cport->rpdev = rpdev;
+
+	dev_set_drvdata(dev, cport);
+
+	dev_dbg(dev, "New channel: 0x%x -> 0x%x: " RPMSG_TTY_NAME "%d\n",
+		rpdev->src, rpdev->dst, cport->id);
+
+	return 0;
+}
+
+static void rpmsg_tty_remove(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+
+	dev_dbg(&rpdev->dev, "Removing rpmsg tty device %d\n", cport->id);
+
+	/* User hang up to release the tty */
+	tty_port_tty_hangup(&cport->port, false);
+
+	tty_unregister_device(rpmsg_tty_driver, cport->id);
+
+	tty_port_put(&cport->port);
+}
+
+static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = {
+	{ .name	= "rpmsg-tty" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table);
+
+static struct rpmsg_driver rpmsg_tty_rpmsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= rpmsg_driver_tty_id_table,
+	.probe		= rpmsg_tty_probe,
+	.callback	= rpmsg_tty_cb,
+	.remove		= rpmsg_tty_remove,
+};
+
+static int __init rpmsg_tty_init(void)
+{
+	int ret;
+
+	rpmsg_tty_driver = tty_alloc_driver(MAX_TTY_RPMSG, TTY_DRIVER_REAL_RAW |
+					    TTY_DRIVER_DYNAMIC_DEV);
+	if (IS_ERR(rpmsg_tty_driver))
+		return PTR_ERR(rpmsg_tty_driver);
+
+	rpmsg_tty_driver->driver_name = "rpmsg_tty";
+	rpmsg_tty_driver->name = RPMSG_TTY_NAME;
+	rpmsg_tty_driver->major = 0;
+	rpmsg_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
+
+	/* Disable unused mode by default */
+	rpmsg_tty_driver->init_termios = tty_std_termios;
+	rpmsg_tty_driver->init_termios.c_lflag &= ~(ECHO | ICANON);
+	rpmsg_tty_driver->init_termios.c_oflag &= ~(OPOST | ONLCR);
+
+	tty_set_operations(rpmsg_tty_driver, &rpmsg_tty_ops);
+
+	ret = tty_register_driver(rpmsg_tty_driver);
+	if (ret < 0) {
+		pr_err("Couldn't install driver: %d\n", ret);
+		goto error_put;
+	}
+
+	ret = register_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	if (ret < 0) {
+		pr_err("Couldn't register driver: %d\n", ret);
+		goto error_unregister;
+	}
+
+	return 0;
+
+error_unregister:
+	tty_unregister_driver(rpmsg_tty_driver);
+
+error_put:
+	tty_driver_kref_put(rpmsg_tty_driver);
+
+	return ret;
+}
+
+static void __exit rpmsg_tty_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	tty_unregister_driver(rpmsg_tty_driver);
+	tty_driver_kref_put(rpmsg_tty_driver);
+	idr_destroy(&tty_idr);
+}
+
+module_init(rpmsg_tty_init);
+module_exit(rpmsg_tty_exit);
+
+MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>");
+MODULE_DESCRIPTION("remote processor messaging tty driver");
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/vrpmdv-monitoring-controler.cold

@@ -0,0 +1,804 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+#include <linux/wait.h>
+
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+//#include "vrpmdv-monitoring-cmd.h"
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+
+#define MSG		"hello Monitoring!"
+
+static int count = 100;
+module_param(count, int, 0644);
+
+struct instance_data {
+	int rx_count;
+};
+
+
+// std::chrono::seconds timeoutPeriod = 5;
+// auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+/**
+ * Generic Netlink will create a Netlink family with this name. Kernel will asign
+ * a numeric ID and afterwards we can talk to the family with its ID. To get
+ * the ID we use Generic Netlink in the userland and pass the family name.
+ *
+ * Short for: Generic Netlink VRPMDV Monitoring  gnl_foobar_mcmd
+ */
+#define FAMILY_NAME "gnl-vrpmdv-mcmd"
+
+/**
+ * These are the attributes that we want to share in gnl_foobar_xmpl.
+ * You can understand an attribute as a semantic type. This is
+ * the payload of Netlink messages.
+ * GNl: Generic Netlink
+ */
+enum GNL_VRPMDV_XMPL_ATTRIBUTE {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_A_UNSPEC,
+    /** We expect a MSG to be a null-terminated C-string. */
+    GNL_VRPMDV_MCMD_A_MSG,
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_A_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN (__GNL_VRPMDV_MCMD_A_MAX)
+/**
+ * The number of actual usable attributes in `enum GNL_VRPMDV_MCMD_ATTRIBUTE`.
+ * This is `GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_COUNT (GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN - 1)
+
+/**
+ * Enumeration of all commands (functions) that our custom protocol on top
+ * of generic netlink supports. This can be understood as the action that
+ * we want to trigger on the receiving side.
+ */
+enum GNL_VRPMDV_MCMD_COMMAND {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_C_UNSPEC,
+
+    // first real command is "1" (>0)
+    /**
+     * When this command is received, we expect the attribute `GNL_VRPMDV_MCMD_ATTRIBUTE::GNL_VRPMDV_MCMD_A_MSG` to
+     * be present in the Generic Netlink request message. The kernel reads the message from the packet and
+     * sent it to the copro. THe result will be return by creating a new Generic Netlink response message 
+     * with an corresponding attribute/payload.
+     *
+     * This command/signaling mechanism is independent of the Netlink flag `NLM_F_ECHO (0x08)`. We use it as
+     * "echo specific data" instead of return a 1:1 copy of the package, which you could do with
+     * `NLM_F_ECHO (0x08)` for example.
+     */
+    GNL_VRPMDV_MCMD_C_MSG,
+
+    /**
+     * Provokes a NLMSG_ERR answer to this request as described in netlink manpage
+     * (https://man7.org/linux/man-pages/man7/netlink.7.html).
+     */
+    GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_C_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN (__GNL_VRPMDV_MCMD_C_MAX)
+/**
+ * The number of actual usable commands  in `enum GNL_FOOBAR_XMPL_COMMAND`.
+ * This is `GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_COUNT (GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN - 1)
+
+#define NODATARECEIVED 0
+#define DATARECEIVED 1
+
+/**
+ * Data structure required for our .doit callback handler to
+ * know about the progress of an ongoing cmd execution.
+ * See the cmd callback handler how it is used.
+ */
+// struct {
+//     // from <linux/mutex.h>
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex sendMTX;
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex receiveCV;
+//     /**
+//      * Wait Queue: if it is signaled we have received data from copro
+//     */
+//     wait_queue_head_t receive_queue;
+//     /**
+//      * Waitflag: 0= no data received, 1 = data received
+//     */
+//     int receive_queue_flag = NODATARECEIVED;
+//     /**
+//      * Condition vaiable signal we have received data from copro
+//     */
+// //    std::condition_variable cv;
+//     // /**
+//     //  * Number that describes how many packets we need to send until we are done
+//     //  * during an ongoing dumpit process. 0 = done.
+//     //  */
+//     // int unsigned runs_to_go;
+//     // /**
+//     //  * Number that describes how many packets per dump are sent in total.
+//     //  * Constant per dump.
+//     //  */
+//     // int unsigned total_runs;
+
+//     //the rpmsg device which sends the data to the copro 
+//     struct rpmsg_device	*rpdev;	/* handle rpmsg device */    
+// } cmd_cb_progress_data;
+
+
+struct rpmsg_vrpmdv_mon_t{
+    // from <linux/mutex.h>
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex sendMTX;
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex receiveCV;
+    /**
+     * Wait Queue: if it is signaled we have received data from copro
+    */
+    wait_queue_head_t receive_queue;
+    /**
+     * Waitflag: 0= no data received, 1 = data received
+    */
+    int receive_queue_flag;
+    //the rpmsg device which sends the data to the copro 
+    struct rpmsg_device* rpdev;	/* handle rpmsg device */    
+};
+
+struct rpmsg_vrpmdv_mon_t vrpmdv_mon;
+
+	// struct mutex	mutex; /* mutex to protect the ioctls */
+	// struct miscdevice mdev; /* misc device ref */
+	// struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	// struct list_head buffer_list; /* buffer instances list */
+
+
+
+// Documentation is on the implementation of this function.
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_VRPMDV_OPS_LEN (GNL_VRPMDV_MCMD_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_vrpmdv_mcmd_ops[GNL_VRPMDV_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_VRPMDV_MCMD_C_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_vrpmdv_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = NULL, //gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = NULL, //gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = NULL, //gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_vrpmdv_mcmd_policy[GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_VRPMDV_MCMD_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_VRPMDV_MCMD_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_vrpmdv_mcmd_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_vrpmdv_mcmd_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_VRPMDV_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_vrpmdv_mcmd_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_VRPMDV_MCMD_C_MSG` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_vrpmdv_mcmd_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_VRPMDV_MCMD_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_VRPMDV_MCMD_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+    //aquire lock for cmd repmsg channel     
+    // std::lock sendlk(cmd_cb_progress_data.sendmtx);    
+
+    //send the message to the copro over RPMSG 
+	rc = rpmsg_send(vrpmdv_mon.rpdev->ept, recv_msg, strlen(recv_msg));
+	if (rc) {
+		pr_err("rpmsg_send failed: %d\n", rc);
+		return rc;
+	}
+
+	// struct rpmsg_vrpmdv_mon_t *drv = dev_get_drvdata(&rpdev->dev);
+
+    {
+        pr_info("wait for response\n");
+        // wait until receive_queue_flag=1 , that means we have received data from Copro
+        wait_event_interruptible(vrpmdv_mon.receive_queue, vrpmdv_mon.receive_queue_flag != 0 );
+        pr_info("received data \n");
+        //Copy data
+        vrpmdv_mon.receive_queue_flag = NODATARECEIVED;
+
+
+
+        // std::unique_lock lk(cmd_cb_progress_data.receivemtx);
+        // if (myCondVar.wait_until(uLock, timePoint) == std::cv_status::timeout)
+        // {
+		//     dev_err(&cmd_cb_progress_data.rpdev, "rpmsg_send failed, timeout: \n");
+        //     return -1:
+        // }
+
+        pr_info("get response: '%s'\n", recv_msg);
+    }
+
+
+
+    // Send a message back after we receive the reply from rpmsg channel
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    // msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+    //                        // According to my findings: this is not used for routing
+    //                        // This can be used in an application specific way to target
+    //                        // different endpoints within the same user application
+    //                        // but general rule: just put sender port id here
+    //                        info->snd_portid, // sending port (not process) id: int
+    //                        info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+    //                        &gnl_vrpmdv_mcmd_family, // struct genl_family *
+    //                        0, // flags for Netlink header: int; application specific and not mandatory
+    //                        // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+    //                        GNL_VRPMDV_MCMD_C_MSG
+    // );
+
+    msg_head = genlmsg_put_reply(reply_skb, // buffer for netlink message: struct sk_buff *
+                                info, // info
+                                &gnl_vrpmdv_mcmd_family, // struct genl_family *
+                                0, // flags for Netlink header: int; application specific and not mandatory
+                                // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                                info->genlhdr->cmd
+    );
+
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_VRPMDV_MCMD_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_VRPMDV_MCMD_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+
+
+
+/**
+ * callback that is called after the copro send data
+ * we have to copy it in a buffer for the netlink and later send it back to the userland
+ * 
+*/
+static int vrpmdv_monitoring_cb(struct rpmsg_device *rpdev, void *data, int len,
+						void *priv, u32 src)
+{
+	int ret = 0;
+	struct instance_data *idata = dev_get_drvdata(&rpdev->dev);
+
+	dev_info(&rpdev->dev, "incoming msg %d (src: 0x%x)\n",
+		 ++idata->rx_count, src);
+
+	print_hex_dump_debug(__func__, DUMP_PREFIX_NONE, 16, 1, data, len,
+			     true);
+
+    vrpmdv_mon.receive_queue_flag= DATARECEIVED;
+    wake_up_interruptible(&(vrpmdv_mon.receive_queue));
+
+	// /* samples should not live forever */
+	// if (idata->rx_count >= count) {
+	// 	dev_info(&rpdev->dev, "goodbye!\n");
+	// 	return 0;
+	// }
+
+	/* send a new message now */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret)
+	// 	dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+
+	return ret;
+}
+
+static int vrpmdv_monitoring_probe(struct rpmsg_device *rpdev)
+{
+    int rc;	
+
+	// int ret;
+	// struct instance_data *idata;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+					rpdev->src, rpdev->dst);
+
+	// idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	// if (!idata)
+	// 	return -ENOMEM;
+
+	// dev_set_drvdata(&rpdev->dev, idata);
+
+	// /* send a message to our remote processor to */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret) {
+	// 	dev_err(&rpdev->dev, "vrpmdv_monitoring_controler_send failed: %d\n", ret);
+	// 	return ret;
+	// }
+
+	// return 0;
+
+	// struct device *dev;
+    // dev = &rpdev->dev;
+	// struct rpmsg_vrpmdv_mon_t *rpmsg_vrpmdv_mon;
+
+	// rpmsg_vrpmdv_mon = devm_kzalloc(dev, sizeof(*rpmsg_vrpmdv_mon), GFP_KERNEL);
+	// if (!rpmsg_vrpmdv_mon)
+	// 	return -ENOMEM;
+
+    mutex_init(&(vrpmdv_mon.sendMTX));
+    init_waitqueue_head (&(vrpmdv_mon.receive_queue));    
+	vrpmdv_mon.rpdev = rpdev;
+
+	// dev_set_drvdata(&rpdev->dev, rpmsg_vrpmdv_mon);
+    pr_info("RPMSG CMD Device set.\n");
+
+
+	/** NEU **/
+    // if (cmd_cb_progress_data.rpdev == NULL) {
+     // cmd_cb_progress_data.rpdev = rpdev;
+     // pr_info("RPMSG CMD Device set.\n");
+    // }
+    // else {
+    //     pr_info("Error: RPMSG CMD Device already set. Don't set it twice\n");        
+    // }
+
+    pr_info("Generic Netlink VRPMDV-Monitroring_Controler Module started.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_vrpmdv_mcmd_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    return 0;
+
+
+
+}
+
+static void vrpmdv_monitoring_remove(struct rpmsg_device *rpdev)
+{
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_vrpmdv_mcmd_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&(vrpmdv_mon.sendMTX));
+    wake_up_interruptible(&(vrpmdv_mon.receive_queue));
+	
+	dev_info(&rpdev->dev, "vrpmdv-monitoring controler driver is removed\n");
+
+}
+
+static struct rpmsg_device_id vrpmdv_monitoring_controler_id_table[] = {
+	{ .name	= "vrpmdv-monitoring-controler" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, vrpmdv_monitoring_controler_id_table);
+
+static struct rpmsg_driver vrpmdv_monitoring_controler = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= vrpmdv_monitoring_controler_id_table,
+	.probe		= vrpmdv_monitoring_probe,
+	.callback	= vrpmdv_monitoring_cb,
+	.remove		= vrpmdv_monitoring_remove,
+};
+module_rpmsg_driver(vrpmdv_monitoring_controler);
+
+
+// static struct rpmsg_driver vrpmdv_monitoring_data = {
+// 	.drv.name	= KBUILD_MODNAME,
+// 	.id_table	= vrpmdv_monitoring_controler_id_table,
+// 	.probe		= vrpmdv_monitoring_probe,
+// 	.callback	= vrpmdv_monitoring_cb,
+// 	.remove		= vrpmdv_monitoring_remove,
+// };
+
+// module_rpmsg_driver(vrpmdv_monitoring_data);
+
+MODULE_DESCRIPTION("Remote processor messaging vrpmdv monitoring controler");
+MODULE_LICENSE("GPL v2");
+
+
+
+// /**
+//  * Module/driver initializer. Called on module load/insertion.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static int __init gnl_foobar_xmpl_module_init(void) {
+//     int rc;
+//     pr_info("Generic Netlink Example Module inserted.\n");
+
+//     // Register family with its operations and policies
+//     rc = genl_register_family(&gnl_foobar_xmpl_family);
+//     if (rc != 0) {
+//         pr_err("FAILED: genl_register_family(): %i\n", rc);
+//         pr_err("An error occurred while inserting the generic netlink example module\n");
+//         return -1;
+//     } else {
+//         pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_init(&dumpit_cb_progress_data.mtx);
+
+//     return 0;
+// }
+
+// /**
+//  * Module/driver uninitializer. Called on module unload/removal.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static void __exit gnl_foobar_xmpl_module_exit(void) {
+//     int ret;
+//     pr_info("Generic Netlink Example Module unloaded.\n");
+
+//     // Unregister the family
+//     ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+//     if (ret != 0) {
+//         pr_err("genl_unregister_family() failed: %i\n", ret);
+//         return;
+//     } else {
+//         pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_destroy(&dumpit_cb_progress_data.mtx);
+// }
+
+
+// ----
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/vrpmdv-monitoring-driver copy.bb.old

@@ -0,0 +1,24 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "CLOSED"
+# LICENSE = "GPL-2.0-only"
+# LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://stm32_rpmsg_sdb.c \
+          "
+# file://75-rpmsg-sdb.rules \
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+# do_install:append() {
+    # udev rules for rpmsg-sdb
+    # install -d ${D}${sysconfdir}/udev/rules.d/
+    # install -m 0644 ${WORKDIR}/75-rpmsg-sdb.rules ${D}${sysconfdir}/udev/rules.d/75-rpmsg-sdb.rules
+# }
+#FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring-driver"

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/vrpmdv-monitoring-driver copy1.bb.old

@@ -0,0 +1,26 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+           file://75-vrpmdv-monitoring.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for vrpmdv-monitoring
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-vrpmdv-monitoring.rules ${D}${sysconfdir}/udev/rules.d/75-vrpmdv-monitoring.rules
+}
+
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/save/vrpmdv-monitoring-driverv2.bb.old

@@ -0,0 +1,26 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+           file://75-vrpmdv-monitoring.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for vrpmdv-monitoring
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-vrpmdv-monitoring.rules ${D}${sysconfdir}/udev/rules.d/75-vrpmdv-monitoring.rules
+}
+
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+FILES:${PN} += "${base_libdir}/modules/"
+
+RPROVIDES:${PN} += "vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-mon-tty/vrpmdv-mon-tty.bb

@@ -0,0 +1,24 @@
+SUMMARY = "VRPMDV Monitoring TTY"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-mon-tty.c \
+           file://75-mon-tty.rules \                      
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+do_install:append() {
+    # udev rules for tty
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-mon-tty.rules ${D}${sysconfdir}/udev/rules.d/75-mon-tty.rules
+}
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-mon-tty"

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/.gitignore

@@ -0,0 +1 @@
+/.~lock.Create-Kernel-Driver.odt#

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "files.associations": {
+        "rpmsg.h": "c",
+        "types.h": "c",
+        "ioctl.h": "c",
+        "wait.h": "c"
+    }
+}

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/files/Makefile

@@ -0,0 +1,26 @@
+# Makefile for VRPMDV Monitoring Controler 
+obj-m := vrpmdv-monitoring-controler.o
+
+
+SRC := $(shell pwd)
+
+all:
+	$(MAKE) -C $(KERNEL_SRC) M=$(SRC)
+
+modules_install:
+	$(MAKE) -C $(KERNEL_SRC) M=$(SRC) modules_install
+
+clean:
+	rm -f *.o *~ core .depend .*.cmd *.ko *.mod.c
+	rm -f Module.markers Module.symvers modules.order
+	rm -rf .tmp_versions Modules.symvers
+
+# obj-m = vrpmdv-monitoring-controler.o
+
+# KVERSION = $(shell uname -r)
+
+# all:
+# 	make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
+
+# clean:
+# 	make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/files/lock.csave

@@ -0,0 +1,116 @@
+include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <thread>
+ 
+std::mutex m;
+std::condition_variable cv;
+std::string data;
+bool ready = false;
+bool processed = false;
+ 
+void worker_thread()
+{
+    // wait until main() sends data
+    std::unique_lock lk(m);
+    cv.wait(lk, []{ return ready; });
+ 
+    // after the wait, we own the lock
+    std::cout << "Worker thread is processing data\n";
+    data += " after processing";
+ 
+    // send data back to main()
+    processed = true;
+    std::cout << "Worker thread signals data processing completed\n";
+ 
+    // manual unlocking is done before notifying, to avoid waking up
+    // the waiting thread only to block again (see notify_one for details)
+    lk.unlock();
+    cv.notify_one();
+}
+ 
+int main()
+{
+    std::thread worker(worker_thread);
+ 
+    data = "Example data";
+    // send data to the worker thread
+    {
+        std::lock_guard lk(m);
+        ready = true;
+        std::cout << "main() signals data ready for processing\n";
+    }
+    cv.notify_one();
+ 
+    // wait for the worker
+    {
+        std::unique_lock lk(m);
+        cv.wait(lk, []{ return processed; });
+    }
+    std::cout << "Back in main(), data = " << data << '\n';
+ 
+    worker.join();
+}
+
+--------------------
+
+// waiting for timeout after 5 seconds
+std::chrono::seconds timeoutPeriod = 5;
+auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+std::unique_lock<std::mutex> uLock(myDataMutex);
+while(!DataAreReadyForProcessing())
+{
+    if (myCondVar.wait_until(uLock, timePoint) //<##
+        == std::cv_status::timeout)
+    {
+        // data conditions where not fulfilled within
+        // the time period; e.g. do some error handling
+        break;
+    }
+}
+
+--
+
+if (myCondVar.wait_for(uLock, timeoutPeriod,
+    DataAreReadyForProcessing))
+{
+    // data conditions where fulfilled
+    // regular processing
+}
+else // timeout occured, conditions are not fulfilled
+{
+    // e.g. do some error handling
+}
+
+
+
+
+
+
+-------------
+
+
+static int rpmsg_sample_probe(struct rpmsg_device *rpdev)
+{
+
+	int ret;
+	struct instance_data *idata;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+					rpdev->src, rpdev->dst);
+
+	idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	if (!idata)
+		return -ENOMEM;
+
+	dev_set_drvdata(&rpdev->dev, idata);
+
+	/* send a message to our remote processor */
+	ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	if (ret) {
+		dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return 0;

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/files/vrpmdv-monitoring-cmd.c

@@ -0,0 +1,541 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+#include "gnl_vrpmdv_mcmd.h"
+
+// Module/Driver description.
+// You can see this for example when executing `$ modinfo ./gnl_vromdv_cmd.ko` (after build).
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("MArkus Lehr <markus@malehr.de>");
+MODULE_DESCRIPTION(
+        "Linux driver that registers the custom Netlink family "
+        "\"" FAMILY_NAME "\" via Generic Netlink and responds to echo messages "
+                         "according to the properties specified in \"gnl_vrpmd_mcmd.h\"."
+);
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+/**
+ * Data structure required for our .dumpit callback handler to
+ * know about the progress of an ongoing dump.
+ * See the dumpit callback handler how it is used.
+ */
+struct {
+    // from <linux/mutex.h>
+    /**
+     * Only one process is allowed per dump process. We need a lock for that.
+     */
+    struct mutex mtx;
+    /**
+     * Number that describes how many packets we need to send until we are done
+     * during an ongoing dumpit process. 0 = done.
+     */
+    int unsigned runs_to_go;
+    /**
+     * Number that describes how many packets per dump are sent in total.
+     * Constant per dump.
+     */
+    int unsigned total_runs;
+} dumpit_cb_progress_data;
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_VRPMDV_OPS_LEN (GNL_VRPMDV_MCMD_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_vrpmdv_mcmd_ops[GNL_VRPMDV_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_VRPMDV_MCMD_C_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_vrpmdv_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_vrpmdv_mcmd_policy[GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_VRPMDV_MCMD_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_VRPMDV_MCMD_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_vrpmdv_mcmd_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_vrpmdv_mcmd_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_VRPMDV_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_vrpmdv_mcmd_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_ECHO` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_FOOBAR_XMPL_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_FOOBAR_XMPL_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+
+    // Send a message back
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+                           // According to my findings: this is not used for routing
+                           // This can be used in an application specific way to target
+                           // different endpoints within the same user application
+                           // but general rule: just put sender port id here
+                           info->snd_portid, // sending port (not process) id: int
+                           info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags for Netlink header: int; application specific and not mandatory
+                           // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG
+    );
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_FOOBAR_XMPL_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_FOOBAR_XMPL_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/** ----------------------    not needed  ML  */
+
+/**
+ * ".dumpit"-callback function if a Generic Netlink with command ECHO_MSG and flag `NLM_F_DUMP` is received.
+ * Please look into the comments where this is used as ".dumpit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".dumpit" callbacks.
+ *
+ * A dump must be understand of "give me all data of a given entity"
+ * rather than a "dump of the netlink message itself" for debugging etc!
+ *
+ * This handler requires `gnl_cb_echo_dumpit_before` to run before a dump and `gnl_cb_echo_dumpit_after` after a dump.
+ *
+ * For the sake of simplicity, we use the ECHO_MSG command for the dump. In fact, we don't expect a
+ * MSG-Attribute here, unlike the regular ECHO_MSG handler. We reply with a dump of
+ * "all messages that we got" (application specific, hard coded in this example).
+*/
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb) {
+    void *msg_head;
+    int ret;
+    static const char HELLO_FROM_DUMPIT_MSG[] = "You set the flag NLM_F_DUMP; this message is "
+                                                "brought to you by .dumpit callback :)";
+    pr_info("Called %s()\n", __func__);
+
+    if (dumpit_cb_progress_data.runs_to_go == 0) {
+        pr_info("no more data to send in dumpit cb\n");
+        // mark that dump is done;
+        return 0;
+    } else {
+        dumpit_cb_progress_data.runs_to_go--;
+        pr_info("%s: %d more runs to do\n", __func__, dumpit_cb_progress_data.runs_to_go);
+    }
+
+    msg_head = genlmsg_put(pre_allocated_skb, // buffer for netlink message: struct sk_buff *
+            // According to my findings: this is not used for routing
+            // This can be used in an application specific way to target
+            // different endpoints within the same user application
+            // but general rule: just put sender port id here
+                           cb->nlh->nlmsg_pid, // sending port (not process) id: int
+            // sequence number: int (might be used by receiver, but not mandatory)
+            // sequence 0, 1, 2...
+                           dumpit_cb_progress_data.total_runs - dumpit_cb_progress_data.runs_to_go - 1,
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags: int (for netlink header); we don't check them in the userland; application specific
+            // this way we can trigger a specific command/callback on the receiving side or imply
+            // on which type of command we are currently answering; this is application specific
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG // cmd: u8 (for generic netlink header);
+    );
+    if (msg_head == NULL) {
+        pr_info("An error occurred in %s(): genlmsg_put() failed\n", __func__);
+        return -ENOMEM;
+    }
+    ret = nla_put_string(
+            pre_allocated_skb,
+            GNL_FOOBAR_XMPL_A_MSG,
+            HELLO_FROM_DUMPIT_MSG
+    );
+    if (ret < 0) {
+        pr_info("An error occurred in %s():\n", __func__);
+        return ret;
+    }
+    genlmsg_end(pre_allocated_skb, msg_head);
+
+    // return the length of data we wrote into the pre-allocated buffer
+    return pre_allocated_skb->len;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before(struct netlink_callback *cb) {
+    int ret;
+    static int unsigned const dump_runs = 3;
+    pr_info("%s: dump started. acquire lock. initialize dump runs_to_go (number of receives userland can make) to %d runs\n", __func__, dump_runs);
+    // Lock the mutex like mutex_lock(), and return 0 if the mutex has been acquired or sleep until the mutex becomes available
+    // If a signal arrives while waiting for the lock then this function returns -EINTR.
+    ret = mutex_lock_interruptible(&dumpit_cb_progress_data.mtx);
+    if (ret != 0) {
+        pr_err("Failed to get lock!\n");
+        return ret;
+    }
+    dumpit_cb_progress_data.total_runs = dump_runs;
+    dumpit_cb_progress_data.runs_to_go = dump_runs;
+    return 0;
+
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb) {
+    pr_info("%s: dump done. release lock\n", __func__);
+    mutex_unlock(&dumpit_cb_progress_data.mtx);
+    return 0;
+}
+
+
+/** ----------------------    not needed  ML  */
+
+
+/** ----------------------    chenge this in the probe of the rpmsg driver   ML  */
+
+/**
+ * Module/driver initializer. Called on module load/insertion.
+ *
+ * @return success (0) or error code.
+ */
+static int __init gnl_foobar_xmpl_module_init(void) {
+    int rc;
+    pr_info("Generic Netlink Example Module inserted.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_foobar_xmpl_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_init(&dumpit_cb_progress_data.mtx);
+
+    return 0;
+}
+
+/**
+ * Module/driver uninitializer. Called on module unload/removal.
+ *
+ * @return success (0) or error code.
+ */
+static void __exit gnl_foobar_xmpl_module_exit(void) {
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&dumpit_cb_progress_data.mtx);
+}
+
+module_init(gnl_foobar_xmpl_module_init);
+module_exit(gnl_foobar_xmpl_module_exit);
+
+/** ----------------------    chenge this in the probe of the rpmsg driver   ML  */

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/files/vrpmdv-monitoring-cmd.h

@@ -0,0 +1,98 @@
+/* Copyright 2021 Philipp Schuster
+ *
+ * This Software is owned by Markus Lehr.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+/*
+ * This file describes the common properties of our custom Netlink family on top of Generic Netlink.
+ * It is used by all C projects, i.e. the Kernel driver, and the userland components.
+ */
+
+/**
+ * Generic Netlink will create a Netlink family with this name. Kernel will asign
+ * a numeric ID and afterwards we can talk to the family with its ID. To get
+ * the ID we use Generic Netlink in the userland and pass the family name.
+ *
+ * Short for: Generic Netlink VRPMDV Monitoring  gnl_foobar_mcmd
+ */
+#define FAMILY_NAME "gnl-vrpmdv-mcmd"
+
+/**
+ * These are the attributes that we want to share in gnl_foobar_xmpl.
+ * You can understand an attribute as a semantic type. This is
+ * the payload of Netlink messages.
+ * GNl: Generic Netlink
+ */
+enum GNL_VRPMDV_XMPL_ATTRIBUTE {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_A_UNSPEC,
+    /** We expect a MSG to be a null-terminated C-string. */
+    GNL_VRPMDV_MCMD_A_MSG,
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_A_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN (__GNL_VRPMDV_MCMD_A_MAX)
+/**
+ * The number of actual usable attributes in `enum GNL_VRPMDV_MCMD_ATTRIBUTE`.
+ * This is `GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_COUNT (GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN - 1)
+
+/**
+ * Enumeration of all commands (functions) that our custom protocol on top
+ * of generic netlink supports. This can be understood as the action that
+ * we want to trigger on the receiving side.
+ */
+enum GNL_VRPMDV_MCMD_COMMAND {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_C_UNSPEC,
+
+    // first real command is "1" (>0)
+    /**
+     * When this command is received, we expect the attribute `GNL_VRPMDV_MCMD_ATTRIBUTE::GNL_VRPMDV_MCMD_A_MSG` to
+     * be present in the Generic Netlink request message. The kernel reads the message from the packet and
+     * sent it to the copro. THe result will be return by creating a new Generic Netlink response message 
+     * with an corresponding attribute/payload.
+     *
+     * This command/signaling mechanism is independent of the Netlink flag `NLM_F_ECHO (0x08)`. We use it as
+     * "echo specific data" instead of return a 1:1 copy of the package, which you could do with
+     * `NLM_F_ECHO (0x08)` for example.
+     */
+    GNL_VRPMDV_MCMD_C_MSG,
+
+    /**
+     * Provokes a NLMSG_ERR answer to this request as described in netlink manpage
+     * (https://man7.org/linux/man-pages/man7/netlink.7.html).
+     */
+    GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_C_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN (__GNL_VRPMDV_MCMD_C_MAX)
+/**
+ * The number of actual usable commands  in `enum GNL_FOOBAR_XMPL_COMMAND`.
+ * This is `GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_COUNT (GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN - 1)

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/files/vrpmdv-monitoring-controler.c

@@ -0,0 +1,865 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+#include <linux/wait.h>
+
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+//#include "vrpmdv-monitoring-cmd.h"
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+
+#define MSG		"hello Monitoring!"
+
+static int count = 100;
+module_param(count, int, 0644);
+
+struct instance_data {
+	int rx_count;
+};
+
+
+// std::chrono::seconds timeoutPeriod = 5;
+// auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+/**
+ * Generic Netlink will create a Netlink family with this name. Kernel will asign
+ * a numeric ID and afterwards we can talk to the family with its ID. To get
+ * the ID we use Generic Netlink in the userland and pass the family name.
+ *
+ * Short for: Generic Netlink VRPMDV Monitoring  gnl_foobar_mcmd
+ */
+#define FAMILY_NAME "gnl-vrpmdv-mcmd"
+
+/**
+ * These are the attributes that we want to share in gnl_foobar_xmpl.
+ * You can understand an attribute as a semantic type. This is
+ * the payload of Netlink messages.
+ * GNl: Generic Netlink
+ */
+enum GNL_VRPMDV_XMPL_ATTRIBUTE {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_A_UNSPEC,
+    /** We expect a MSG to be a null-terminated C-string. */
+    GNL_VRPMDV_MCMD_A_MSG,
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_A_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN (__GNL_VRPMDV_MCMD_A_MAX)
+/**
+ * The number of actual usable attributes in `enum GNL_VRPMDV_MCMD_ATTRIBUTE`.
+ * This is `GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_COUNT (GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN - 1)
+
+/**
+ * Enumeration of all commands (functions) that our custom protocol on top
+ * of generic netlink supports. This can be understood as the action that
+ * we want to trigger on the receiving side.
+ */
+enum GNL_VRPMDV_MCMD_COMMAND {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_C_UNSPEC,
+
+    // first real command is "1" (>0)
+    /**
+     * When this command is received, we expect the attribute `GNL_VRPMDV_MCMD_ATTRIBUTE::GNL_VRPMDV_MCMD_A_MSG` to
+     * be present in the Generic Netlink request message. The kernel reads the message from the packet and
+     * sent it to the copro. THe result will be return by creating a new Generic Netlink response message 
+     * with an corresponding attribute/payload.
+     *
+     * This command/signaling mechanism is independent of the Netlink flag `NLM_F_ECHO (0x08)`. We use it as
+     * "echo specific data" instead of return a 1:1 copy of the package, which you could do with
+     * `NLM_F_ECHO (0x08)` for example.
+     */
+    GNL_VRPMDV_MCMD_C_MSG,
+
+    /**
+     * Provokes a NLMSG_ERR answer to this request as described in netlink manpage
+     * (https://man7.org/linux/man-pages/man7/netlink.7.html).
+     */
+    GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_C_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN (__GNL_VRPMDV_MCMD_C_MAX)
+/**
+ * The number of actual usable commands  in `enum GNL_FOOBAR_XMPL_COMMAND`.
+ * This is `GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_COUNT (GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN - 1)
+
+#define NODATARECEIVED 0
+#define DATARECEIVED 1
+
+/**
+ * Data structure required for our .doit callback handler to
+ * know about the progress of an ongoing cmd execution.
+ * See the cmd callback handler how it is used.
+ */
+// struct {
+//     // from <linux/mutex.h>
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex sendMTX;
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex receiveCV;
+//     /**
+//      * Wait Queue: if it is signaled we have received data from copro
+//     */
+//     wait_queue_head_t receive_queue;
+//     /**
+//      * Waitflag: 0= no data received, 1 = data received
+//     */
+//     int receive_queue_flag = NODATARECEIVED;
+//     /**
+//      * Condition vaiable signal we have received data from copro
+//     */
+// //    std::condition_variable cv;
+//     // /**
+//     //  * Number that describes how many packets we need to send until we are done
+//     //  * during an ongoing dumpit process. 0 = done.
+//     //  */
+//     // int unsigned runs_to_go;
+//     // /**
+//     //  * Number that describes how many packets per dump are sent in total.
+//     //  * Constant per dump.
+//     //  */
+//     // int unsigned total_runs;
+
+//     //the rpmsg device which sends the data to the copro 
+//     struct rpmsg_device	*rpdev;	/* handle rpmsg device */    
+// } cmd_cb_progress_data;
+
+
+// struct rpmsg_vrpmdv_mon_t{
+//     // from <linux/mutex.h>
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex sendMTX;
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex receiveCV;
+//     /**
+//      * Wait Queue: if it is signaled we have received data from copro
+//     */
+//     wait_queue_head_t receive_queue;
+//     /**
+//      * Waitflag: 0= no data received, 1 = data received
+//     */
+//     int receive_queue_flag;
+//     //the rpmsg device which sends the data to the copro 
+//     struct rpmsg_device* rpdev;	/* handle rpmsg device */    
+// };
+
+// struct rpmsg_vrpmdv_mon_t vrpmdv_mon;
+
+
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex sendMTX;
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex receiveCV;
+    /**
+     * Wait Queue: if it is signaled we have received data from copro
+    */
+    wait_queue_head_t receive_queue;
+    /**
+     * Waitflag: 0= no data received, 1 = data received
+    */
+    int receive_queue_flag = NODATARECEIVED;
+
+    char* received_bytes = NULL;
+    int   received_len = 0;
+    //the rpmsg device which sends the data to the copro 
+    struct rpmsg_device* prpdev = NULL;	/* handle rpmsg device */    
+
+
+	// struct mutex	mutex; /* mutex to protect the ioctls */
+	// struct miscdevice mdev; /* misc device ref */
+	// struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	// struct list_head buffer_list; /* buffer instances list */
+
+
+
+// Documentation is on the implementation of this function.
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_VRPMDV_OPS_LEN (GNL_VRPMDV_MCMD_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_vrpmdv_mcmd_ops[GNL_VRPMDV_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_VRPMDV_MCMD_C_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_vrpmdv_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = NULL, //gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = NULL, //gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = NULL, //gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_vrpmdv_mcmd_policy[GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_VRPMDV_MCMD_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_VRPMDV_MCMD_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_vrpmdv_mcmd_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_vrpmdv_mcmd_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_VRPMDV_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_vrpmdv_mcmd_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_VRPMDV_MCMD_C_MSG` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_vrpmdv_mcmd_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_VRPMDV_MCMD_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_VRPMDV_MCMD_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+    //aquire lock for cmd repmsg channel     
+    // std::lock sendlk(cmd_cb_progress_data.sendmtx);    
+
+    //send the message to the copro over RPMSG 
+    if (prpdev) {
+        rc = rpmsg_send(prpdev->ept, recv_msg, strlen(recv_msg));
+        if (rc) {
+            pr_err("rpmsg_send failed: %d\n", rc);
+            return rc;
+        }
+
+        // struct rpmsg_vrpmdv_mon_t *drv = dev_get_drvdata(&rpdev->dev);
+
+        // Send a message back after we receive the reply from rpmsg channel
+        // ---------------------
+
+        // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+        reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (reply_skb == NULL) {
+            pr_err("An error occurred in %s():\n", __func__);
+            return -ENOMEM;
+        }
+
+        // Create the message headersprpdev
+
+        // Add header to netlink message;
+        // afterwards the buffer looks like this:
+        // ----------------------------------
+        // | netlink header                 |
+        // | generic netlink header         |
+        // | <space for netlink attributes> |
+        // ----------------------------------
+        // msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+        //                        // According to my findings: this is not used for routing
+        //                        // This can be used in an application specific way to target
+        //                        // different endpoints within the same user application
+        //                        // but general rule: just put sender port id here
+        //                        info->snd_portid, // sending port (not process) id: int
+        //                        info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+        //                        &gnl_vrpmdv_mcmd_family, // struct genl_family *
+        //                        0, // flags for Netlink header: int; application specific and not mandatory
+        //                        // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+        //                        GNL_VRPMDV_MCMD_C_MSG
+        // );
+
+        msg_head = genlmsg_put_reply(reply_skb, // buffer for netlink message: struct sk_buff *
+                                    info, // info
+                                    &gnl_vrpmdv_mcmd_family, // struct genl_family *
+                                    0, // flags for Netlink header: int; application specific and not mandatory
+                                    // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                                    info->genlhdr->cmd
+        );
+
+        if (msg_head == NULL) {
+            rc = ENOMEM;
+            pr_err("An error occurred in %s():\n", __func__);
+            return -rc;
+        }
+
+        {
+            pr_info("wait for response\n");
+            // wait until receive_queue_flag=1 , that means we have received data from Copro
+            wait_event_interruptible(receive_queue, receive_queue_flag != 0 );
+            
+            //Copy data
+            receive_queue_flag = NODATARECEIVED;
+
+
+
+            // std::unique_lock lk(cmd_cb_progress_data.receivemtx);
+            // if (myCondVar.wait_until(uLock, timePoint) == std::cv_status::timeout)
+            // {
+            //     dev_err(&cmd_cb_progress_data.rpdev, "rpmsg_send failed, timeout: \n");
+            //     return -1:
+            // }
+
+            //pr_info("get response: '%s'\n", recv_msg);
+            if (received_len > 0) {                
+                pr_info("received data from copro %s\n", received_bytes);                
+            }
+            else {
+                pr_err("don't received data from Copro \n");                
+            }
+
+        }
+
+        // Add a GNL_VRPMDV_MCMD_A_MSG attribute (actual value/payload to be sent)
+        // echo the value we just received
+        rc = nla_put_string(reply_skb, GNL_VRPMDV_MCMD_A_MSG, received_bytes);
+
+        if (rc != 0) {
+            pr_err("An error occurred in %s():\n", __func__);
+            //free the buffer
+            kfree(received_bytes);
+            received_bytes = NULL;
+            return -rc;
+        }
+
+        // Finalize the message:
+        // Corrects the netlink message header (length) to include the appended
+        // attributes. Only necessary if attributes have been added to the message.
+        genlmsg_end(reply_skb, msg_head);
+
+        // Send the message back
+        rc = genlmsg_reply(reply_skb, info);
+        // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+        // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+        kfree(received_bytes);
+        received_bytes = NULL;
+
+        if (rc != 0) {
+            pr_err("An error occurred in %s():\n", __func__);
+            return -rc;
+        }
+        return 0;
+    
+    }
+    pr_info("Device not set in Probe. Should not happen");
+    return -1;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+
+
+
+/**
+ * callback that is called after the copro send data
+ * we have to copy it in a buffer for the netlink and later send it back to the userland
+ * 
+*/
+static int vrpmdv_monitoring_cb(struct rpmsg_device *rpdev, void *data, int len,
+						void *priv, u32 src)
+{
+	int ret = 0;
+	// struct instance_data *idata = dev_get_drvdata(&rpdev->dev);
+
+	// dev_info(&rpdev->dev, "incoming msg %d (src: 0x%x)\n",
+	// 	 ++idata->rx_count, src);
+
+	print_hex_dump_debug(__func__, DUMP_PREFIX_NONE, 16, 1, data, len,
+			     true);
+   	if (len == 0) {
+		pr_err("(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+    else {
+        pr_info("received data from copro %s\n", (char*) data);                
+    }
+    
+    // received_bytes = (char *)kmalloc(len+1, GFP_KERNEL);
+	// memcpy(received_bytes, data, len);
+
+    // rpmsg_RxBuf[len] = 0;
+
+
+
+    received_bytes = (char *)kmalloc(len, GFP_KERNEL);
+	memcpy(received_bytes, data, len);    
+    received_len = len;
+    receive_queue_flag= DATARECEIVED;
+    wake_up_interruptible(&receive_queue);
+
+	// /* samples should not live forever */
+	// if (idata->rx_count >= count) {
+	// 	dev_info(&rpdev->dev, "goodbye!\n");
+	// 	return 0;
+	// }
+
+	/* send a new message now */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret)
+	// 	dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+
+	return ret;
+}
+
+static int vrpmdv_monitoring_probe(struct rpmsg_device *rpdev)
+{
+    int rc;	
+
+	// int ret;
+	// struct instance_data *idata;
+
+	// dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+	// 				rpdev->src, rpdev->dst);
+
+    pr_info("RPMSG monitroing control device driver started.\n");
+
+	// idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	// if (!idata)
+	// 	return -ENOMEM;
+
+	// dev_set_drvdata(&rpdev->dev, idata);
+
+	// /* send a message to our remote processor to */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret) {
+	// 	dev_err(&rpdev->dev, "vrpmdv_monitoring_controler_send failed: %d\n", ret);
+	// 	return ret;
+	// }
+
+	// return 0;
+
+	// struct device *dev;
+    // dev = &rpdev->dev;
+	// struct rpmsg_vrpmdv_mon_t *rpmsg_vrpmdv_mon;
+
+	// rpmsg_vrpmdv_mon = devm_kzalloc(dev, sizeof(*rpmsg_vrpmdv_mon), GFP_KERNEL);
+	// if (!rpmsg_vrpmdv_mon)
+	// 	return -ENOMEM;
+
+    mutex_init(&sendMTX);
+    init_waitqueue_head (&receive_queue);    
+	prpdev = rpdev;
+
+	// dev_set_drvdata(&rpdev->dev, rpmsg_vrpmdv_mon);
+    pr_info("RPMSG CMD Device set.\n");
+
+
+	/** NEU **/
+    // if (cmd_cb_progress_data.rpdev == NULL) {
+     // cmd_cb_progress_data.rpdev = rpdev;
+     // pr_info("RPMSG CMD Device set.\n");
+    // }
+    // else {
+    //     pr_info("Error: RPMSG CMD Device already set. Don't set it twice\n");        
+    // }
+
+    pr_info("Generic Netlink VRPMDV-Monitroring_Controler Module started.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_vrpmdv_mcmd_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    return 0;
+
+
+
+}
+
+static void vrpmdv_monitoring_remove(struct rpmsg_device *rpdev)
+{
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_vrpmdv_mcmd_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&sendMTX);
+    wake_up_interruptible(&receive_queue);
+
+	pr_info("vrpmdv-monitoring controler driver is removed\n");	
+	// dev_info(&rpdev->dev, "vrpmdv-monitoring controler driver is removed\n");
+
+}
+
+static struct rpmsg_device_id vrpmdv_monitoring_controler_id_table[] = {
+	{ .name	= "vrpmdv-monitoring-controler" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, vrpmdv_monitoring_controler_id_table);
+
+static struct rpmsg_driver vrpmdv_monitoring_controler = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= vrpmdv_monitoring_controler_id_table,
+	.probe		= vrpmdv_monitoring_probe,
+	.callback	= vrpmdv_monitoring_cb,
+	.remove		= vrpmdv_monitoring_remove,
+};
+module_rpmsg_driver(vrpmdv_monitoring_controler);
+
+
+// static struct rpmsg_driver vrpmdv_monitoring_data = {
+// 	.drv.name	= KBUILD_MODNAME,
+// 	.id_table	= vrpmdv_monitoring_controler_id_table,
+// 	.probe		= vrpmdv_monitoring_probe,
+// 	.callback	= vrpmdv_monitoring_cb,
+// 	.remove		= vrpmdv_monitoring_remove,
+// };
+
+// module_rpmsg_driver(vrpmdv_monitoring_data);
+
+MODULE_DESCRIPTION("Remote processor messaging vrpmdv monitoring controler");
+MODULE_LICENSE("GPL v2");
+
+
+
+// /**
+//  * Module/driver initializer. Called on module load/insertion.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static int __init gnl_foobar_xmpl_module_init(void) {
+//     int rc;
+//     pr_info("Generic Netlink Example Module inserted.\n");
+
+//     // Register family with its operations and policies
+//     rc = genl_register_family(&gnl_foobar_xmpl_family);
+//     if (rc != 0) {
+//         pr_err("FAILED: genl_register_family(): %i\n", rc);
+//         pr_err("An error occurred while inserting the generic netlink example module\n");
+//         return -1;
+//     } else {
+//         pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_init(&dumpit_cb_progress_data.mtx);
+
+//     return 0;
+// }
+
+// /**
+//  * Module/driver uninitializer. Called on module unload/removal.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static void __exit gnl_foobar_xmpl_module_exit(void) {
+//     int ret;
+//     pr_info("Generic Netlink Example Module unloaded.\n");
+
+//     // Unregister the family
+//     ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+//     if (ret != 0) {
+//         pr_err("genl_unregister_family() failed: %i\n", ret);
+//         return;
+//     } else {
+//         pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_destroy(&dumpit_cb_progress_data.mtx);
+// }
+
+
+// ----
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/kernel-module-vrpmdv-monitoring-driver.bb

@@ -0,0 +1,16 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/netlink-save.c.save

@@ -0,0 +1,541 @@
+/* Copyright 2021 Philipp Schuster
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of 
+ * this software and associated documentation files (the "Software"), to deal in the 
+ * Software without restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies
+ * or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "gnl_foobar_xmpl" which shows you the basics of using
+ * Generic Netlink in the kernel. It registers a Netlink family called "gnl_foobar_xmpl". See
+ * "gnl_foobar_xmpl_prop.h" for common properties of the family. "Generic Netlink" offers us a lot of
+ * convenient functions to register new/custom Netlink families on the fly during runtime. We use this
+ * functionality here. It implements simple IPC between Userland and Kernel (Kernel responds to userland).
+ *
+ * Check "gnl_foobar_xmpl_prop.h" for common properties of the family first, afterwards follow the code here.
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+#include "gnl_foobar_xmpl_prop.h"
+
+// Module/Driver description.
+// You can see this for example when executing `$ modinfo ./gnl_foobar_xmpl.ko` (after build).
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Philipp Schuster <phip1611@gmail.com>");
+MODULE_DESCRIPTION(
+        "Linux driver that registers the custom Netlink family "
+        "\"" FAMILY_NAME "\" via Generic Netlink and responds to echo messages "
+                         "according to the properties specified in \"gnl_foobar_xmpl_prop.h\"."
+);
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+/**
+ * Data structure required for our .dumpit callback handler to
+ * know about the progress of an ongoing dump.
+ * See the dumpit callback handler how it is used.
+ */
+struct {
+    // from <linux/mutex.h>
+    /**
+     * Only one process is allowed per dump process. We need a lock for that.
+     */
+    struct mutex mtx;
+    /**
+     * Number that describes how many packets we need to send until we are done
+     * during an ongoing dumpit process. 0 = done.
+     */
+    int unsigned runs_to_go;
+    /**
+     * Number that describes how many packets per dump are sent in total.
+     * Constant per dump.
+     */
+    int unsigned total_runs;
+} dumpit_cb_progress_data;
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_FOOBAR_OPS_LEN (GNL_FOOBAR_XMPL_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_foobar_xmpl_ops[GNL_FOOBAR_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_FOOBAR_XMPL_C_ECHO_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_echo_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_foobar_xmpl_policy[GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_FOOBAR_XMPL_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_FOOBAR_XMPL_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_foobar_xmpl_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_foobar_xmpl_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_FOOBAR_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_foobar_xmpl_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_FOOBAR_XMPL_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_ECHO` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_echo_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_FOOBAR_XMPL_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_FOOBAR_XMPL_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+
+    // Send a message back
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+                           // According to my findings: this is not used for routing
+                           // This can be used in an application specific way to target
+                           // different endpoints within the same user application
+                           // but general rule: just put sender port id here
+                           info->snd_portid, // sending port (not process) id: int
+                           info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags for Netlink header: int; application specific and not mandatory
+                           // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG
+    );
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_FOOBAR_XMPL_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_FOOBAR_XMPL_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/**
+ * ".dumpit"-callback function if a Generic Netlink with command ECHO_MSG and flag `NLM_F_DUMP` is received.
+ * Please look into the comments where this is used as ".dumpit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".dumpit" callbacks.
+ *
+ * A dump must be understand of "give me all data of a given entity"
+ * rather than a "dump of the netlink message itself" for debugging etc!
+ *
+ * This handler requires `gnl_cb_echo_dumpit_before` to run before a dump and `gnl_cb_echo_dumpit_after` after a dump.
+ *
+ * For the sake of simplicity, we use the ECHO_MSG command for the dump. In fact, we don't expect a
+ * MSG-Attribute here, unlike the regular ECHO_MSG handler. We reply with a dump of
+ * "all messages that we got" (application specific, hard coded in this example).
+*/
+int gnl_cb_echo_dumpit(struct sk_buff *pre_allocated_skb, struct netlink_callback *cb) {
+    void *msg_head;
+    int ret;
+    static const char HELLO_FROM_DUMPIT_MSG[] = "You set the flag NLM_F_DUMP; this message is "
+                                                "brought to you by .dumpit callback :)";
+    pr_info("Called %s()\n", __func__);
+
+    if (dumpit_cb_progress_data.runs_to_go == 0) {
+        pr_info("no more data to send in dumpit cb\n");
+        // mark that dump is done;
+        return 0;
+    } else {
+        dumpit_cb_progress_data.runs_to_go--;
+        pr_info("%s: %d more runs to do\n", __func__, dumpit_cb_progress_data.runs_to_go);
+    }
+
+    msg_head = genlmsg_put(pre_allocated_skb, // buffer for netlink message: struct sk_buff *
+            // According to my findings: this is not used for routing
+            // This can be used in an application specific way to target
+            // different endpoints within the same user application
+            // but general rule: just put sender port id here
+                           cb->nlh->nlmsg_pid, // sending port (not process) id: int
+            // sequence number: int (might be used by receiver, but not mandatory)
+            // sequence 0, 1, 2...
+                           dumpit_cb_progress_data.total_runs - dumpit_cb_progress_data.runs_to_go - 1,
+                           &gnl_foobar_xmpl_family, // struct genl_family *
+                           0, // flags: int (for netlink header); we don't check them in the userland; application specific
+            // this way we can trigger a specific command/callback on the receiving side or imply
+            // on which type of command we are currently answering; this is application specific
+                           GNL_FOOBAR_XMPL_C_ECHO_MSG // cmd: u8 (for generic netlink header);
+    );
+    if (msg_head == NULL) {
+        pr_info("An error occurred in %s(): genlmsg_put() failed\n", __func__);
+        return -ENOMEM;
+    }
+    ret = nla_put_string(
+            pre_allocated_skb,
+            GNL_FOOBAR_XMPL_A_MSG,
+            HELLO_FROM_DUMPIT_MSG
+    );
+    if (ret < 0) {
+        pr_info("An error occurred in %s():\n", __func__);
+        return ret;
+    }
+    genlmsg_end(pre_allocated_skb, msg_head);
+
+    // return the length of data we wrote into the pre-allocated buffer
+    return pre_allocated_skb->len;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before(struct netlink_callback *cb) {
+    int ret;
+    static int unsigned const dump_runs = 3;
+    pr_info("%s: dump started. acquire lock. initialize dump runs_to_go (number of receives userland can make) to %d runs\n", __func__, dump_runs);
+    // Lock the mutex like mutex_lock(), and return 0 if the mutex has been acquired or sleep until the mutex becomes available
+    // If a signal arrives while waiting for the lock then this function returns -EINTR.
+    ret = mutex_lock_interruptible(&dumpit_cb_progress_data.mtx);
+    if (ret != 0) {
+        pr_err("Failed to get lock!\n");
+        return ret;
+    }
+    dumpit_cb_progress_data.total_runs = dump_runs;
+    dumpit_cb_progress_data.runs_to_go = dump_runs;
+    return 0;
+
+}
+
+/**
+ * Called before a dump with `gnl_cb_echo_dumpit()` starts.
+ * See where this is assigned in `struct genl_ops gnl_foobar_xmpl_ops[]` as
+ * `.start` callback for more comments.
+ *
+ * @return success (0) or error.
+ */
+int	gnl_cb_echo_dumpit_before_after(struct netlink_callback *cb) {
+    pr_info("%s: dump done. release lock\n", __func__);
+    mutex_unlock(&dumpit_cb_progress_data.mtx);
+    return 0;
+}
+
+/**
+ * Module/driver initializer. Called on module load/insertion.
+ *
+ * @return success (0) or error code.
+ */
+static int __init gnl_foobar_xmpl_module_init(void) {
+    int rc;
+    pr_info("Generic Netlink Example Module inserted.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_foobar_xmpl_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_init(&dumpit_cb_progress_data.mtx);
+
+    return 0;
+}
+
+/**
+ * Module/driver uninitializer. Called on module unload/removal.
+ *
+ * @return success (0) or error code.
+ */
+static void __exit gnl_foobar_xmpl_module_exit(void) {
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&dumpit_cb_progress_data.mtx);
+}
+
+module_init(gnl_foobar_xmpl_module_init);
+module_exit(gnl_foobar_xmpl_module_exit);

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/rpmsg_sdb.csva

@@ -0,0 +1,536 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) STMicroelectronics 2019 - All Rights Reserved
+ * Author: Jean-Philippe Romain <jean-philippe.romain@st.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/miscdevice.h>
+#include <linux/eventfd.h>
+#include <linux/of_platform.h>
+#include <linux/list.h>
+
+#define RPMSG_SDB_DRIVER_VERSION "1.0"
+
+/*
+ * Static global variables
+ */
+static const char rpmsg_sdb_driver_name[] = "stm32-rpmsg-sdb";
+
+static int LastBufferId;
+
+struct rpmsg_sdb_ioctl_set_efd {
+	int bufferId, eventfd;
+};
+
+struct rpmsg_sdb_ioctl_get_data_size {
+	int bufferId;
+	uint32_t size;
+};
+
+/* ioctl numbers */
+/* _IOW means userland is writing and kernel is reading */
+/* _IOR means userland is reading and kernel is writing */
+/* _IOWR means userland and kernel can both read and write */
+#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
+#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
+
+struct sdb_buf_t {
+	int index; /* index of buffer */
+	size_t size; /* buffer size */
+	size_t writing_size; /* size of data written by copro */
+	dma_addr_t paddr; /* physical address*/
+	void *vaddr; /* virtual address */
+	void *uaddr; /* mapped address for userland */
+	struct eventfd_ctx *efd_ctx; /* eventfd context */
+	struct list_head buflist; /* reference in the buffers list */
+};
+
+struct rpmsg_sdb_t {
+	struct mutex	mutex; /* mutex to protect the ioctls */
+	struct miscdevice mdev; /* misc device ref */
+	struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	struct list_head buffer_list; /* buffer instances list */
+};
+
+struct device *rpmsg_sdb_dev;
+
+static int rpmsg_sdb_format_txbuf_string(struct sdb_buf_t *buffer, char *bufinfo_str, size_t bufinfo_str_size)
+{
+	pr_debug("rpmsg_sdb(%s): Buffer index:%d, addr:%08x, size:%08x\n",
+				__func__,
+				buffer->index,
+				buffer->paddr,
+				buffer->size);
+	return snprintf(bufinfo_str, bufinfo_str_size, "B%dA%08xL%08x", buffer->index, buffer->paddr, buffer->size);
+}
+
+static long rpmsg_sdb_decode_rxbuf_string(char *rxbuf_str, int *buffer_id, size_t *size)
+{
+	int ret = 0;
+	char *sub_str;
+	long bsize;
+	long bufid;
+	const char delimiter[2] = {'L','\0'};
+
+	pr_debug("rpmsg_sdb(%s): rxbuf_str:%s\n", __func__, rxbuf_str);
+
+	/* Get first part containing the buffer id */
+	sub_str = strsep(&rxbuf_str, delimiter);
+
+	pr_debug("rpmsg_sdb(%s): sub_str:%s\n", __func__, sub_str);
+
+	/* Save Buffer id and size: template BxLyyyyyyyy*/
+	ret = kstrtol(&sub_str[1], 10, &bufid);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer id failed(%d)", ret);
+		goto out;
+	}
+
+	ret = kstrtol(&rxbuf_str[2], 16, &bsize);
+	if (ret < 0) {
+		pr_err("rpmsg_sdb(ERROR): Extract of buffer size failed(%d)", ret);
+		goto out;
+	}
+
+	*size = (size_t)bsize;
+	*buffer_id = (int)bufid;
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_send_buf_info(struct rpmsg_sdb_t *rpmsg_sdb, struct sdb_buf_t *buffer)
+{
+	int count = 0, ret = 0;
+	const unsigned char *tbuf;
+	char mybuf[32];
+	int msg_size;
+	struct rpmsg_device *_rpdev;
+
+	_rpdev = rpmsg_sdb->rpdev;
+	msg_size = rpmsg_get_buffer_size(_rpdev->ept);
+
+	if (msg_size < 0)
+		return msg_size;
+
+	count = rpmsg_sdb_format_txbuf_string(buffer, mybuf, 32);
+	tbuf = &mybuf[0];
+
+	do {
+		/* send a message to our remote processor */
+		ret = rpmsg_send(_rpdev->ept, (void *)tbuf,
+				 count > msg_size ? msg_size : count);
+		if (ret) {
+			dev_err(&_rpdev->dev, "rpmsg_send failed: %d\n", ret);
+			return ret;
+		}
+
+		if (count > msg_size) {
+			count -= msg_size;
+			tbuf += msg_size;
+		} else {
+			count = 0;
+		}
+	} while (count > 0);
+
+	return count;
+}
+
+static int rpmsg_sdb_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long vsize = vma->vm_end - vma->vm_start;
+	unsigned long size = PAGE_ALIGN(vsize);
+	unsigned long NumPages = size >> PAGE_SHIFT;
+	unsigned long align = get_order(size);
+	pgprot_t prot = pgprot_noncached(vma->vm_page_prot);
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *_buffer;
+
+	if (align > CONFIG_CMA_ALIGNMENT)
+		align = CONFIG_CMA_ALIGNMENT;
+
+	if (rpmsg_sdb_dev == NULL)
+		return -ENOMEM;
+
+	rpmsg_sdb_dev->coherent_dma_mask = DMA_BIT_MASK(32);
+	rpmsg_sdb_dev->dma_mask = &rpmsg_sdb_dev->coherent_dma_mask;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Field the last buffer entry which is the last one created */
+	if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+		_buffer = list_last_entry(&_rpmsg_sdb->buffer_list,
+									struct sdb_buf_t, buflist);
+
+		_buffer->uaddr = NULL;
+		_buffer->size = NumPages * PAGE_SIZE;
+		_buffer->writing_size = -1;
+		_buffer->vaddr = dma_alloc_coherent(rpmsg_sdb_dev,
+							_buffer->size,
+							&_buffer->paddr,
+							GFP_KERNEL);
+
+		if (!_buffer->vaddr) {
+			pr_err("rpmsg_sdb(ERROR): Memory allocation issue\n");
+			return -ENOMEM;
+		}
+
+		pr_debug("rpmsg_sdb(%s): dma_alloc_coherent done - paddr[%d]:%x - vaddr[%d]:%p\n",
+					__func__,
+					_buffer->index,
+					_buffer->paddr,
+					_buffer->index,
+					_buffer->vaddr);
+
+		/* Get address for userland */
+		if (remap_pfn_range(vma, vma->vm_start,
+							(_buffer->paddr >> PAGE_SHIFT) + vma->vm_pgoff,
+							size, prot))
+			return -EAGAIN;
+
+		_buffer->uaddr = (void *)vma->vm_start;
+
+		/* Send information to remote proc */
+		rpmsg_sdb_send_buf_info(_rpmsg_sdb, _buffer);
+	} else {
+		dev_err(rpmsg_sdb_dev, "No existing buffer entry exist in the list !!!");
+		return -EINVAL;
+	}
+
+	/* Increment for number of requested buffer */
+	LastBufferId++;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_open - Open Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_open(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	/* Initialize the buffer list*/
+	INIT_LIST_HEAD(&_rpmsg_sdb->buffer_list);
+
+	mutex_init(&_rpmsg_sdb->mutex);
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_close - Close Session
+ *
+ * @inode:	inode struct
+ * @file:	file struct
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static int rpmsg_sdb_close(struct inode *inode, struct file *file)
+{
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *pos, *next;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+												mdev);
+
+	list_for_each_entry_safe(pos, next, &_rpmsg_sdb->buffer_list, buflist) {
+		/* Free the CMA allocation */
+		pr_debug("rpmsg_sdb(%s): Free the CMA allocation: pos->size:%08x, pos->vaddr:%08x, pos->paddr:%08x\n",
+					__func__,
+					pos->size,
+					pos->vaddr,
+					pos->paddr);
+
+		dma_free_coherent(rpmsg_sdb_dev, pos->size, pos->vaddr,
+					pos->paddr);
+		/* Remove the buffer from the list */
+		list_del(&pos->buflist);
+		/* Free the buffer */
+		kfree(pos);
+	}
+
+	/* Reset LastBufferId */
+	LastBufferId = 0;
+
+	return 0;
+}
+
+/**
+ * rpmsg_sdb_ioctl - IOCTL
+ *
+ * @session:	ibmvmc_file_session struct
+ * @cmd:	cmd field
+ * @arg:	Argument field
+ *
+ * Return:
+ *	0 - Success
+ *	Non-zero - Failure
+ */
+static long rpmsg_sdb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int idx = 0;
+
+	struct rpmsg_sdb_t *_rpmsg_sdb;
+	struct sdb_buf_t *buffer, *lastbuffer;
+
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_ioctl_set_efd q_set_efd;
+	struct rpmsg_sdb_ioctl_get_data_size q_get_dat_size;
+
+	void __user *argp = (void __user *)arg;
+
+	_rpmsg_sdb = container_of(file->private_data, struct rpmsg_sdb_t,
+								mdev);
+
+	switch (cmd) {
+	case RPMSG_SDB_IOCTL_SET_EFD:
+		mutex_lock(&_rpmsg_sdb->mutex);
+
+		/* Get index from the last buffer in the list */
+		if (!list_empty(&_rpmsg_sdb->buffer_list)) {
+			lastbuffer = list_last_entry(&_rpmsg_sdb->buffer_list, struct sdb_buf_t, buflist);
+			idx = lastbuffer->index;
+			
+			/* Check last index was properly initiated*/
+			if (lastbuffer->vaddr == NULL) {
+				pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - previous buffer was not allocated\n");
+				mutex_unlock(&_rpmsg_sdb->mutex);
+				return -EBADE;
+			}
+
+			/* increment this index for the next buffer creation*/
+			idx++;
+		}
+
+		if (copy_from_user(&q_set_efd, (struct rpmsg_sdb_ioctl_set_efd *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_set_efd))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_SET_EFD - copy from user failed\n");
+			mutex_unlock(&_rpmsg_sdb->mutex);
+			return -EFAULT;
+		}
+
+		/* create a new buffer which will be added in the buffer list */
+		buffer = kmalloc(sizeof(struct sdb_buf_t), GFP_KERNEL);
+
+		buffer->index = idx;
+		buffer->vaddr = NULL;
+		buffer->efd_ctx = eventfd_ctx_fdget(q_set_efd.eventfd);
+		list_add_tail(&buffer->buflist, &_rpmsg_sdb->buffer_list);
+
+		mutex_unlock(&_rpmsg_sdb->mutex);
+		break;
+
+	case RPMSG_SDB_IOCTL_GET_DATA_SIZE:
+		if (copy_from_user(&q_get_dat_size, (struct rpmsg_sdb_ioctl_get_data_size *)argp,
+					sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy from user failed\n");
+			return -EFAULT;
+		}
+
+		/* Get the index of the requested buffer and then look-up in the buffer list*/
+		idx = q_get_dat_size.bufferId;
+
+		list_for_each(pos, &_rpmsg_sdb->buffer_list)
+		{
+			datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+			if (datastructureptr->index == idx) {
+				/* Get the writing size*/
+				q_get_dat_size.size = datastructureptr->writing_size;
+				break;
+			}
+		}
+
+		if (copy_to_user((struct rpmsg_sdb_ioctl_get_data_size *)argp, &q_get_dat_size,
+					 sizeof(struct rpmsg_sdb_ioctl_get_data_size))) {
+			pr_err("rpmsg_sdb(ERROR): RPMSG_SDB_IOCTL_GET_DATA_SIZE - copy to user failed\n");
+			return -EFAULT;
+		}
+
+		/* Reset the writing size*/
+		datastructureptr->writing_size = -1;
+
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations rpmsg_sdb_fops = {
+	.owner			= THIS_MODULE,
+	.unlocked_ioctl	= rpmsg_sdb_ioctl,
+	.mmap			= rpmsg_sdb_mmap,
+	.open           = rpmsg_sdb_open,
+	.release        = rpmsg_sdb_close,
+};
+
+static int rpmsg_sdb_drv_cb(struct rpmsg_device *rpdev, void *data, int len,
+			void *priv, u32 src)
+{
+	int ret = 0;
+	int buffer_id = 0;
+	size_t buffer_size;
+	char *rpmsg_RxBuf;
+	struct list_head *pos;
+	struct sdb_buf_t *datastructureptr = NULL;
+
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpdev->dev);
+
+	if (len == 0) {
+		dev_err(rpmsg_sdb_dev, "(%s) Empty lenght requested\n", __func__);
+		return -EINVAL;
+	}
+
+    //dev_err(rpmsg_sdb_dev, "(%s) lenght: %d\n", __func__,len);
+
+    rpmsg_RxBuf = (char *)kmalloc(len+1, GFP_KERNEL);
+	memcpy(rpmsg_RxBuf, data, len);
+
+    rpmsg_RxBuf[len] = 0;
+
+	ret = rpmsg_sdb_decode_rxbuf_string(rpmsg_RxBuf, &buffer_id, &buffer_size);
+    kfree(rpmsg_RxBuf);
+	if (ret < 0)
+		goto out;
+
+	if (buffer_id > LastBufferId) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Signal to User space application */
+	list_for_each(pos, &drv->buffer_list)
+	{
+		datastructureptr = list_entry(pos, struct sdb_buf_t, buflist);
+		if (datastructureptr->index == buffer_id) {
+			datastructureptr->writing_size = buffer_size;
+
+			if (datastructureptr->writing_size > datastructureptr->size) {
+				dev_err(rpmsg_sdb_dev, "(%s) Writing size is bigger than buffer size\n", __func__);
+				ret = -EINVAL;
+				goto out;
+			}
+
+			eventfd_signal(datastructureptr->efd_ctx, 1);
+			break;
+		}
+		/* TODO: quid if nothing find during the loop ? */
+	}
+
+out:
+	return ret;
+}
+
+static int rpmsg_sdb_drv_probe(struct rpmsg_device *rpdev)
+{
+	int ret = 0;
+	struct device *dev = &rpdev->dev;
+	struct rpmsg_sdb_t *rpmsg_sdb;
+
+	rpmsg_sdb = devm_kzalloc(dev, sizeof(*rpmsg_sdb), GFP_KERNEL);
+	if (!rpmsg_sdb)
+		return -ENOMEM;
+
+	mutex_init(&rpmsg_sdb->mutex);
+
+	rpmsg_sdb->rpdev = rpdev;
+
+	rpmsg_sdb->mdev.name = "rpmsg-sdb";
+	rpmsg_sdb->mdev.minor = MISC_DYNAMIC_MINOR;
+	rpmsg_sdb->mdev.fops = &rpmsg_sdb_fops;
+
+	dev_set_drvdata(&rpdev->dev, rpmsg_sdb);
+
+	/* Register misc device */
+	ret = misc_register(&rpmsg_sdb->mdev);
+
+	if (ret) {
+		dev_err(dev, "Failed to register device\n");
+		goto err_out;
+	}
+
+	rpmsg_sdb_dev = rpmsg_sdb->mdev.this_device;
+
+	dev_info(dev, "%s probed\n", rpmsg_sdb_driver_name);
+
+err_out:
+	return ret;
+}
+
+static void rpmsg_sdb_drv_remove(struct rpmsg_device *rpmsgdev)
+{
+	struct rpmsg_sdb_t *drv = dev_get_drvdata(&rpmsgdev->dev);
+
+	misc_deregister(&drv->mdev);
+}
+
+static struct rpmsg_device_id rpmsg_driver_sdb_id_table[] = {
+	{ .name	= "rpmsg-sdb-channel" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sdb_id_table);
+
+static struct rpmsg_driver rpmsg_sdb_rmpsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_sdb_id_table,
+	.probe		= rpmsg_sdb_drv_probe,
+	.callback	= rpmsg_sdb_drv_cb,
+	.remove		= rpmsg_sdb_drv_remove,
+};
+
+static int __init rpmsg_sdb_drv_init(void)
+{
+	int ret = 0;
+
+	/* Register rpmsg device */
+	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+	if (ret) {
+		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+		return ret;
+	}
+
+	pr_info("rpmsg_sdb: Init done\n");
+
+	return ret;
+}
+
+static void __exit rpmsg_sdb_drv_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+	pr_info("rpmsg_sdb: Exit\n");
+}
+
+module_init(rpmsg_sdb_drv_init);
+module_exit(rpmsg_sdb_drv_exit);
+
+
+MODULE_AUTHOR("Jean-Philippe Romain <jean-philippe.romain@st.com>");
+MODULE_DESCRIPTION("shared data buffer over RPMSG");
+MODULE_VERSION(RPMSG_SDB_DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/ttyrpmsg.csave

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 STMicroelectronics - All Rights Reserved
+ *
+ * The rpmsg tty driver implements serial communication on the RPMsg bus to makes
+ * possible for user-space programs to send and receive rpmsg messages as a standard
+ * tty protocol.
+ *
+ * The remote processor can instantiate a new tty by requesting a "rpmsg-tty" RPMsg service.
+ * The "rpmsg-tty" service is directly used for data exchange. No flow control is implemented yet.
+ */
+
+#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#define RPMSG_TTY_NAME	"ttyRPMSG"
+#define MAX_TTY_RPMSG	32
+
+static DEFINE_IDR(tty_idr);	/* tty instance id */
+static DEFINE_MUTEX(idr_lock);	/* protects tty_idr */
+
+static struct tty_driver *rpmsg_tty_driver;
+
+struct rpmsg_tty_port {
+	struct tty_port		port;	 /* TTY port data */
+	int			id;	 /* TTY rpmsg index */
+	struct rpmsg_device	*rpdev;	 /* rpmsg device */
+};
+
+static int rpmsg_tty_cb(struct rpmsg_device *rpdev, void *data, int len, void *priv, u32 src)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+	int copied;
+
+	if (!len)
+		return -EINVAL;
+	copied = tty_insert_flip_string(&cport->port, data, len);
+	if (copied != len)
+		dev_err_ratelimited(&rpdev->dev, "Trunc buffer: available space is %d\n", copied);
+	tty_flip_buffer_push(&cport->port);
+
+	return 0;
+}
+
+static int rpmsg_tty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = idr_find(&tty_idr, tty->index);
+	struct tty_port *port;
+
+	tty->driver_data = cport;
+
+	port = tty_port_get(&cport->port);
+	return tty_port_install(port, driver, tty);
+}
+
+static void rpmsg_tty_cleanup(struct tty_struct *tty)
+{
+	tty_port_put(tty->port);
+}
+
+static int rpmsg_tty_open(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_open(tty->port, tty, filp);
+}
+
+static void rpmsg_tty_close(struct tty_struct *tty, struct file *filp)
+{
+	return tty_port_close(tty->port, tty, filp);
+}
+
+static int rpmsg_tty_write(struct tty_struct *tty, const u8 *buf, int len)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	struct rpmsg_device *rpdev;
+	int msg_max_size, msg_size;
+	int ret;
+
+	rpdev = cport->rpdev;
+
+	msg_max_size = rpmsg_get_mtu(rpdev->ept);
+	if (msg_max_size < 0)
+		return msg_max_size;
+
+	msg_size = min(len, msg_max_size);
+
+	/*
+	 * Use rpmsg_trysend instead of rpmsg_send to send the message so the caller is not
+	 * hung until a rpmsg buffer is available. In such case rpmsg_trysend returns -ENOMEM.
+	 */
+	ret = rpmsg_trysend(rpdev->ept, (void *)buf, msg_size);
+	if (ret) {
+		dev_dbg_ratelimited(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+		return ret;
+	}
+
+	return msg_size;
+}
+
+static unsigned int rpmsg_tty_write_room(struct tty_struct *tty)
+{
+	struct rpmsg_tty_port *cport = tty->driver_data;
+	int size;
+
+	size = rpmsg_get_mtu(cport->rpdev->ept);
+	if (size < 0)
+		return 0;
+
+	return size;
+}
+
+static void rpmsg_tty_hangup(struct tty_struct *tty)
+{
+	tty_port_hangup(tty->port);
+}
+
+static const struct tty_operations rpmsg_tty_ops = {
+	.install	= rpmsg_tty_install,
+	.open		= rpmsg_tty_open,
+	.close		= rpmsg_tty_close,
+	.write		= rpmsg_tty_write,
+	.write_room	= rpmsg_tty_write_room,
+	.hangup		= rpmsg_tty_hangup,
+	.cleanup	= rpmsg_tty_cleanup,
+};
+
+static struct rpmsg_tty_port *rpmsg_tty_alloc_cport(void)
+{
+	struct rpmsg_tty_port *cport;
+	int ret;
+
+	cport = kzalloc(sizeof(*cport), GFP_KERNEL);
+	if (!cport)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_lock(&idr_lock);
+	ret = idr_alloc(&tty_idr, cport, 0, MAX_TTY_RPMSG, GFP_KERNEL);
+	mutex_unlock(&idr_lock);
+
+	if (ret < 0) {
+		kfree(cport);
+		return ERR_PTR(ret);
+	}
+
+	cport->id = ret;
+
+	return cport;
+}
+
+static void rpmsg_tty_destruct_port(struct tty_port *port)
+{
+	struct rpmsg_tty_port *cport = container_of(port, struct rpmsg_tty_port, port);
+
+	mutex_lock(&idr_lock);
+	idr_remove(&tty_idr, cport->id);
+	mutex_unlock(&idr_lock);
+
+	kfree(cport);
+}
+
+static const struct tty_port_operations rpmsg_tty_port_ops = {
+	.destruct = rpmsg_tty_destruct_port,
+};
+
+
+static int rpmsg_tty_probe(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport;
+	struct device *dev = &rpdev->dev;
+	struct device *tty_dev;
+	int ret;
+
+	cport = rpmsg_tty_alloc_cport();
+	if (IS_ERR(cport))
+		return dev_err_probe(dev, PTR_ERR(cport), "Failed to alloc tty port\n");
+
+	tty_port_init(&cport->port);
+	cport->port.ops = &rpmsg_tty_port_ops;
+
+	tty_dev = tty_port_register_device(&cport->port, rpmsg_tty_driver,
+					   cport->id, dev);
+	if (IS_ERR(tty_dev)) {
+		ret = dev_err_probe(dev, PTR_ERR(tty_dev), "Failed to register tty port\n");
+		tty_port_put(&cport->port);
+		return ret;
+	}
+
+	cport->rpdev = rpdev;
+
+	dev_set_drvdata(dev, cport);
+
+	dev_dbg(dev, "New channel: 0x%x -> 0x%x: " RPMSG_TTY_NAME "%d\n",
+		rpdev->src, rpdev->dst, cport->id);
+
+	return 0;
+}
+
+static void rpmsg_tty_remove(struct rpmsg_device *rpdev)
+{
+	struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev);
+
+	dev_dbg(&rpdev->dev, "Removing rpmsg tty device %d\n", cport->id);
+
+	/* User hang up to release the tty */
+	tty_port_tty_hangup(&cport->port, false);
+
+	tty_unregister_device(rpmsg_tty_driver, cport->id);
+
+	tty_port_put(&cport->port);
+}
+
+static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = {
+	{ .name	= "rpmsg-tty" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table);
+
+static struct rpmsg_driver rpmsg_tty_rpmsg_drv = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= rpmsg_driver_tty_id_table,
+	.probe		= rpmsg_tty_probe,
+	.callback	= rpmsg_tty_cb,
+	.remove		= rpmsg_tty_remove,
+};
+
+static int __init rpmsg_tty_init(void)
+{
+	int ret;
+
+	rpmsg_tty_driver = tty_alloc_driver(MAX_TTY_RPMSG, TTY_DRIVER_REAL_RAW |
+					    TTY_DRIVER_DYNAMIC_DEV);
+	if (IS_ERR(rpmsg_tty_driver))
+		return PTR_ERR(rpmsg_tty_driver);
+
+	rpmsg_tty_driver->driver_name = "rpmsg_tty";
+	rpmsg_tty_driver->name = RPMSG_TTY_NAME;
+	rpmsg_tty_driver->major = 0;
+	rpmsg_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
+
+	/* Disable unused mode by default */
+	rpmsg_tty_driver->init_termios = tty_std_termios;
+	rpmsg_tty_driver->init_termios.c_lflag &= ~(ECHO | ICANON);
+	rpmsg_tty_driver->init_termios.c_oflag &= ~(OPOST | ONLCR);
+
+	tty_set_operations(rpmsg_tty_driver, &rpmsg_tty_ops);
+
+	ret = tty_register_driver(rpmsg_tty_driver);
+	if (ret < 0) {
+		pr_err("Couldn't install driver: %d\n", ret);
+		goto error_put;
+	}
+
+	ret = register_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	if (ret < 0) {
+		pr_err("Couldn't register driver: %d\n", ret);
+		goto error_unregister;
+	}
+
+	return 0;
+
+error_unregister:
+	tty_unregister_driver(rpmsg_tty_driver);
+
+error_put:
+	tty_driver_kref_put(rpmsg_tty_driver);
+
+	return ret;
+}
+
+static void __exit rpmsg_tty_exit(void)
+{
+	unregister_rpmsg_driver(&rpmsg_tty_rpmsg_drv);
+	tty_unregister_driver(rpmsg_tty_driver);
+	tty_driver_kref_put(rpmsg_tty_driver);
+	idr_destroy(&tty_idr);
+}
+
+module_init(rpmsg_tty_init);
+module_exit(rpmsg_tty_exit);
+
+MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>");
+MODULE_DESCRIPTION("remote processor messaging tty driver");
+MODULE_LICENSE("GPL v2");

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/vrpmdv-monitoring-controler.cold

@@ -0,0 +1,804 @@
+/* Copyright 2024 Markus Lehr
+ *
+ *
+ * This Software is owned by Markus Lehr.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+// ##################################################################################################
+/*
+ * This is a Linux kernel module/driver called "vrpmdv-monitoring-cmd " which holds the family ID 
+ * and functions to handle the monitoring in a Generic Netlink in the kernel.  
+ * "It registers a Netlink family called "vrpmdv-monitoring_cmd".
+ *
+ *
+ * You can find some more interesting documentation about Generic Netlink here:
+ * "Generic Netlink HOW-TO based on Jamal's original doc" https://lwn.net/Articles/208755/
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/rpmsg.h>
+
+// basic definitions for kernel module development
+#include <linux/module.h>
+// definitions for generic netlink families, policies etc;
+// transitive dependencies for basic netlink, sockets etc
+#include <net/genetlink.h>
+// required for locking inside the .dumpit callback demonstration
+#include <linux/mutex.h>
+#include <linux/wait.h>
+
+
+// data/vars/enums/properties that describes our protocol that we implement
+// on top of generic netlink (like functions we want to trigger on the receiving side)
+//#include "vrpmdv-monitoring-cmd.h"
+
+
+/* ######################## CONVENIENT LOGGING MACROS ######################## */
+// (Re)definition of some convenient logging macros from <linux/printk.h>. You can see the logging
+// messages when printing the kernel log, e.g. with `$ sudo dmesg`.
+// See https://elixir.bootlin.com/linux/latest/source/include/linux/printk.h
+
+// with this redefinition we can easily prefix all log messages from pr_* logging macros
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+/* ########################################################################### */
+
+
+#define MSG		"hello Monitoring!"
+
+static int count = 100;
+module_param(count, int, 0644);
+
+struct instance_data {
+	int rx_count;
+};
+
+
+// std::chrono::seconds timeoutPeriod = 5;
+// auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+/**
+ * Generic Netlink will create a Netlink family with this name. Kernel will asign
+ * a numeric ID and afterwards we can talk to the family with its ID. To get
+ * the ID we use Generic Netlink in the userland and pass the family name.
+ *
+ * Short for: Generic Netlink VRPMDV Monitoring  gnl_foobar_mcmd
+ */
+#define FAMILY_NAME "gnl-vrpmdv-mcmd"
+
+/**
+ * These are the attributes that we want to share in gnl_foobar_xmpl.
+ * You can understand an attribute as a semantic type. This is
+ * the payload of Netlink messages.
+ * GNl: Generic Netlink
+ */
+enum GNL_VRPMDV_XMPL_ATTRIBUTE {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_A_UNSPEC,
+    /** We expect a MSG to be a null-terminated C-string. */
+    GNL_VRPMDV_MCMD_A_MSG,
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_A_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN (__GNL_VRPMDV_MCMD_A_MAX)
+/**
+ * The number of actual usable attributes in `enum GNL_VRPMDV_MCMD_ATTRIBUTE`.
+ * This is `GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_ATTRIBUTE_COUNT (GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN - 1)
+
+/**
+ * Enumeration of all commands (functions) that our custom protocol on top
+ * of generic netlink supports. This can be understood as the action that
+ * we want to trigger on the receiving side.
+ */
+enum GNL_VRPMDV_MCMD_COMMAND {
+    /**
+     * 0 is never used (=> UNSPEC), you can also see this in other family definitions in Linux code.
+     * We do the same, although I'm not sure, if this is really enforced by code.
+     */
+    GNL_VRPMDV_MCMD_C_UNSPEC,
+
+    // first real command is "1" (>0)
+    /**
+     * When this command is received, we expect the attribute `GNL_VRPMDV_MCMD_ATTRIBUTE::GNL_VRPMDV_MCMD_A_MSG` to
+     * be present in the Generic Netlink request message. The kernel reads the message from the packet and
+     * sent it to the copro. THe result will be return by creating a new Generic Netlink response message 
+     * with an corresponding attribute/payload.
+     *
+     * This command/signaling mechanism is independent of the Netlink flag `NLM_F_ECHO (0x08)`. We use it as
+     * "echo specific data" instead of return a 1:1 copy of the package, which you could do with
+     * `NLM_F_ECHO (0x08)` for example.
+     */
+    GNL_VRPMDV_MCMD_C_MSG,
+
+    /**
+     * Provokes a NLMSG_ERR answer to this request as described in netlink manpage
+     * (https://man7.org/linux/man-pages/man7/netlink.7.html).
+     */
+    GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+
+    /** Unused marker field to get the length/count of enum entries. No real attribute. */
+    __GNL_VRPMDV_MCMD_C_MAX,
+};
+/**
+ * Number of elements in `enum GNL_VRPMDV_MCMD_COMMAND`.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN (__GNL_VRPMDV_MCMD_C_MAX)
+/**
+ * The number of actual usable commands  in `enum GNL_FOOBAR_XMPL_COMMAND`.
+ * This is `GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN` - 1 because "UNSPEC" is never used.
+ */
+#define GNL_VRPMDV_MCMD_COMMAND_COUNT (GNL_VRPMDV_MCMD_COMMAND_ENUM_LEN - 1)
+
+#define NODATARECEIVED 0
+#define DATARECEIVED 1
+
+/**
+ * Data structure required for our .doit callback handler to
+ * know about the progress of an ongoing cmd execution.
+ * See the cmd callback handler how it is used.
+ */
+// struct {
+//     // from <linux/mutex.h>
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex sendMTX;
+//     /**
+//      * rpmsg wait for response from copro side.
+//      */
+//     struct mutex receiveCV;
+//     /**
+//      * Wait Queue: if it is signaled we have received data from copro
+//     */
+//     wait_queue_head_t receive_queue;
+//     /**
+//      * Waitflag: 0= no data received, 1 = data received
+//     */
+//     int receive_queue_flag = NODATARECEIVED;
+//     /**
+//      * Condition vaiable signal we have received data from copro
+//     */
+// //    std::condition_variable cv;
+//     // /**
+//     //  * Number that describes how many packets we need to send until we are done
+//     //  * during an ongoing dumpit process. 0 = done.
+//     //  */
+//     // int unsigned runs_to_go;
+//     // /**
+//     //  * Number that describes how many packets per dump are sent in total.
+//     //  * Constant per dump.
+//     //  */
+//     // int unsigned total_runs;
+
+//     //the rpmsg device which sends the data to the copro 
+//     struct rpmsg_device	*rpdev;	/* handle rpmsg device */    
+// } cmd_cb_progress_data;
+
+
+struct rpmsg_vrpmdv_mon_t{
+    // from <linux/mutex.h>
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex sendMTX;
+    /**
+     * rpmsg wait for response from copro side.
+     */
+    struct mutex receiveCV;
+    /**
+     * Wait Queue: if it is signaled we have received data from copro
+    */
+    wait_queue_head_t receive_queue;
+    /**
+     * Waitflag: 0= no data received, 1 = data received
+    */
+    int receive_queue_flag;
+    //the rpmsg device which sends the data to the copro 
+    struct rpmsg_device* rpdev;	/* handle rpmsg device */    
+};
+
+struct rpmsg_vrpmdv_mon_t vrpmdv_mon;
+
+	// struct mutex	mutex; /* mutex to protect the ioctls */
+	// struct miscdevice mdev; /* misc device ref */
+	// struct rpmsg_device	*rpdev;	/* handle rpmsg device */
+	// struct list_head buffer_list; /* buffer instances list */
+
+
+
+// Documentation is on the implementation of this function.
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info);
+
+// Documentation is on the implementation of this function.
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info);
+
+/**
+ * The length of `struct genl_ops gnl_foobar_xmpl_ops[]`. Not necessarily
+ * the number of commands in `enum GNlFoobarXmplCommand`. It depends on your application logic.
+ * For example, you can use the same command multiple times and - dependent by flag -
+ * invoke a different callback handler. In our simple example we just use one .doit callback
+ * per operation/command.
+ */
+#define GNL_VRPMDV_OPS_LEN (GNL_VRPMDV_MCMD_COMMAND_COUNT)
+
+/**
+ * Array with all operations that our protocol on top of Generic Netlink
+ * supports. An operation is the glue between a command ("cmd" field in `struct genlmsghdr` of
+ * received Generic Netlink message) and the corresponding ".doit" callback function.
+ * See: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L148
+ */
+struct genl_ops gnl_vrpmdv_mcmd_ops[GNL_VRPMDV_OPS_LEN] = {
+        {
+                /* The "cmd" field in `struct genlmsghdr` of received Generic Netlink message */
+                .cmd = GNL_VRPMDV_MCMD_C_MSG,
+                /* TODO Use case ? */
+                .flags = 0,
+                /* TODO Use case ? */
+                .internal_flags = 0,
+                /* Callback handler when a request with the specified ".cmd" above is received.
+                 * Always validates the payload except one set NO_STRICT_VALIDATION flag in ".validate"
+                 * See: https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The 'doit' handler should do whatever processing is necessary and return
+                 *   zero on success, or a negative value on failure.  Negative return values
+                 *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+                 *   only cause a NLMSG_ERROR message to be sent if the request is received with
+                 *   the NLM_F_ACK flag set."
+                 *
+                 * You can find this in Linux code here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+                 *
+                 * One can find more information about NLMSG_ERROR responses and how to handle them
+                 * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+                 *
+                 */
+                .doit = gnl_cb_vrpmdv_doit,
+                /* This callback is similar in use to the standard Netlink 'dumpit' callback.
+                 * The 'dumpit' callback is invoked when a Generic Netlink message is received
+                 * with the NLM_F_DUMP flag set.
+                 *
+                 * A dump can be understand as a "GET ALL DATA OF THE GIVEN ENTITY", i.e.
+                 * the userland can receive as long as the .dumpit callback returns data.
+                 *
+                 * .dumpit is not mandatory, but either it or .doit must be provided, see
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L367
+                 *
+                 * To be honest I don't know in what use case one should use .dumpit and why
+                 * it is useful, because you can achieve the same also with .doit handlers.
+                 * Anyway, this is just an example/tutorial.
+                 *
+                 * Quote from: https://lwn.net/Articles/208755
+                 *  "The main difference between a 'dumpit' handler and a 'doit' handler is
+                 *   that a 'dumpit' handler does not allocate a message buffer for a response;
+                 *   a pre-allocated sk_buff is passed to the 'dumpit' handler as the first
+                 *   parameter.  The 'dumpit' handler should fill the message buffer with the
+                 *   appropriate response message and return the size of the sk_buff,
+                 *   i.e. sk_buff->len, and the message buffer will automatically be sent to the
+                 *   Generic Netlink client that initiated the request.  As long as the 'dumpit'
+                 *   handler returns a value greater than zero it will be called again with a
+                 *   newly allocated message buffer to fill, when the handler has no more data
+                 *   to send it should return zero; error conditions are indicated by returning
+                 *   a negative value.  If necessary, state can be preserved in the
+                 *   netlink_callback parameter which is passed to the 'dumpit' handler; the
+                 *   netlink_callback parameter values will be preserved across handler calls
+                 *   for a single request."
+                 *
+                 * You can see the check for the NLM_F_DUMP-flag here:
+                 * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L780
+                 */
+                .dumpit = NULL, //gnl_cb_echo_dumpit,
+                /* Start callback for dumps. Can be used to lock data structures. */
+                .start = NULL, //gnl_cb_echo_dumpit_before,
+                /* Completion callback for dumps. Can be used for cleanup after a dump and releasing locks. */
+                .done = NULL, //gnl_cb_echo_dumpit_before_after,
+                /*
+                 0 (= "validate strictly") or value `enum genl_validate_flags`
+                 * see: https://elixir.bootlin.com/linux/v5.11/source/include/net/genetlink.h#L108
+                 */
+                .validate = 0,
+        },
+        {
+                .cmd = GNL_VRPMDV_MCMD_C_REPLY_WITH_NLMSG_ERR,
+                .flags = 0,
+                .internal_flags = 0,
+                .doit = gnl_cb_doit_reply_with_nlmsg_err,
+                // .dumpit is not required, only optional; application specific/dependent on your use case
+                // in a real application you probably have different .dumpit handlers per operation/command
+                .dumpit = NULL,
+                // in a real application you probably have different .start handlers per operation/command
+                .start = NULL,
+                // in a real application you probably have different .done handlers per operation/command
+                .done = NULL,
+                .validate = 0,
+        }
+};
+
+
+/**
+ * Attribute policy: defines which attribute has which type (e.g int, char * etc).
+ * This get validated for each received Generic Netlink message, if not deactivated
+ * in `gnl_foobar_xmpl_ops[].validate`.
+ * See https://elixir.bootlin.com/linux/v5.11/source/net/netlink/genetlink.c#L717
+ */
+static struct nla_policy gnl_vrpmdv_mcmd_policy[GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN] = {
+        // In case you are seeing this syntax for the first time (I also learned this just after a few years of
+        // coding with C myself): The following static array initiations are equivalent:
+        // `int a[2] = {1, 2}` <==> `int a[2] = {[0] => 1, [1] => 2}`.
+
+        [GNL_VRPMDV_MCMD_A_UNSPEC] = {.type = NLA_UNSPEC},
+
+        // You can set this to NLA_U32 for testing and send an ECHO message from the userland
+        // It will fail in this case and you see a entry in the kernel log.
+
+        // `enum GNL_FOOBAR_XMPL_ATTRIBUTE::GNL_FOOBAR_XMPL_A_MSG` is a null-terminated C-String
+        [GNL_VRPMDV_MCMD_A_MSG] = {.type = NLA_NUL_STRING},
+};
+
+
+
+/**
+ * Definition of the Netlink family we want to register using Generic Netlink functionality
+ */
+static struct genl_family gnl_vrpmdv_mcmd_family = {
+        // automatically assign an id
+        .id = 0,
+        // we don't use custom additional header info / user specific header
+        .hdrsize = 0,
+        // The name of this family, used by userspace application to get the numeric ID
+        .name = FAMILY_NAME,
+        // family specific version number; can be used to evolve application over time (multiple versions)
+        .version = 1,
+        // delegates all incoming requests to callback functions
+        .ops = gnl_vrpmdv_mcmd_ops,
+        // length of array `gnl_foobar_xmpl_ops`
+        .n_ops = GNL_VRPMDV_OPS_LEN,
+        // attribute policy (for validation of messages). Enforced automatically, except ".validate" in
+        // corresponding ".ops"-field is set accordingly.
+        .policy = gnl_vrpmdv_mcmd_policy,
+        // Number of attributes / bounds check for policy (array length)
+        .maxattr = GNL_VRPMDV_MCMD_ATTRIBUTE_ENUM_LEN,
+        // Owning Kernel module of the Netlink family we register.
+        .module = THIS_MODULE,
+
+        // Actually not necessary because this memory region would be zeroed anyway during module load,
+        // but this way one sees all possible options.
+
+        // if your application must handle multiple netlink calls in parallel (where one should not block the next
+        // from starting), set this to true! otherwise all netlink calls are mutually exclusive
+        .parallel_ops = 0,
+        // set to true if the family can handle network namespaces and should be presented in all of them
+        .netnsok = 0,
+        // called before an operation's doit callback, it may do additional, common, filtering and return an error
+        .pre_doit = NULL,
+        // called after an operation's doit callback, it may undo operations done by pre_doit, for example release locks
+        .post_doit = NULL,
+};
+
+
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_VRPMDV_MCMD_C_MSG` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_vrpmdv_mcmd_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_vrpmdv_doit(struct sk_buff *sender_skb, struct genl_info *info) {
+    struct nlattr *na;
+    struct sk_buff *reply_skb;
+    int rc;
+    void *msg_head;
+    char *recv_msg;
+
+    pr_info("%s() invoked\n", __func__);
+
+    if (info == NULL) {
+        // should never happen
+        pr_err("An error occurred in %s():\n", __func__);
+        return -EINVAL;
+    }
+
+    /*
+     * For each attribute there is an index in info->attrs which points to a nlattr structure
+     * in this structure the data is stored.
+     */
+    na = info->attrs[GNL_VRPMDV_MCMD_A_MSG];
+
+    if (!na) {
+        pr_err("no info->attrs[%i]\n", GNL_VRPMDV_MCMD_A_MSG);
+        return -EINVAL; // we return here because we expect to recv a msg
+    }
+
+    recv_msg = (char *) nla_data(na);
+    if (recv_msg == NULL) {
+        pr_err("error while receiving data\n");
+    } else {
+        pr_info("received: '%s'\n", recv_msg);
+    }
+
+    //aquire lock for cmd repmsg channel     
+    // std::lock sendlk(cmd_cb_progress_data.sendmtx);    
+
+    //send the message to the copro over RPMSG 
+	rc = rpmsg_send(vrpmdv_mon.rpdev->ept, recv_msg, strlen(recv_msg));
+	if (rc) {
+		pr_err("rpmsg_send failed: %d\n", rc);
+		return rc;
+	}
+
+	// struct rpmsg_vrpmdv_mon_t *drv = dev_get_drvdata(&rpdev->dev);
+
+    {
+        pr_info("wait for response\n");
+        // wait until receive_queue_flag=1 , that means we have received data from Copro
+        wait_event_interruptible(vrpmdv_mon.receive_queue, vrpmdv_mon.receive_queue_flag != 0 );
+        pr_info("received data \n");
+        //Copy data
+        vrpmdv_mon.receive_queue_flag = NODATARECEIVED;
+
+
+
+        // std::unique_lock lk(cmd_cb_progress_data.receivemtx);
+        // if (myCondVar.wait_until(uLock, timePoint) == std::cv_status::timeout)
+        // {
+		//     dev_err(&cmd_cb_progress_data.rpdev, "rpmsg_send failed, timeout: \n");
+        //     return -1:
+        // }
+
+        pr_info("get response: '%s'\n", recv_msg);
+    }
+
+
+
+    // Send a message back after we receive the reply from rpmsg channel
+    // ---------------------
+
+    // Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
+    reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+    if (reply_skb == NULL) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -ENOMEM;
+    }
+
+    // Create the message headers
+
+    // Add header to netlink message;
+    // afterwards the buffer looks like this:
+    // ----------------------------------
+    // | netlink header                 |
+    // | generic netlink header         |
+    // | <space for netlink attributes> |
+    // ----------------------------------
+    // msg_head = genlmsg_put(reply_skb, // buffer for netlink message: struct sk_buff *
+    //                        // According to my findings: this is not used for routing
+    //                        // This can be used in an application specific way to target
+    //                        // different endpoints within the same user application
+    //                        // but general rule: just put sender port id here
+    //                        info->snd_portid, // sending port (not process) id: int
+    //                        info->snd_seq + 1, // sequence number: int (might be used by receiver, but not mandatory)
+    //                        &gnl_vrpmdv_mcmd_family, // struct genl_family *
+    //                        0, // flags for Netlink header: int; application specific and not mandatory
+    //                        // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+    //                        GNL_VRPMDV_MCMD_C_MSG
+    // );
+
+    msg_head = genlmsg_put_reply(reply_skb, // buffer for netlink message: struct sk_buff *
+                                info, // info
+                                &gnl_vrpmdv_mcmd_family, // struct genl_family *
+                                0, // flags for Netlink header: int; application specific and not mandatory
+                                // The command/operation (u8) from `enum GNL_FOOBAR_XMPL_COMMAND` for Generic Netlink header
+                                info->genlhdr->cmd
+    );
+
+    if (msg_head == NULL) {
+        rc = ENOMEM;
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Add a GNL_VRPMDV_MCMD_A_MSG attribute (actual value/payload to be sent)
+    // echo the value we just received
+    rc = nla_put_string(reply_skb, GNL_VRPMDV_MCMD_A_MSG, recv_msg);
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+
+    // Finalize the message:
+    // Corrects the netlink message header (length) to include the appended
+    // attributes. Only necessary if attributes have been added to the message.
+    genlmsg_end(reply_skb, msg_head);
+
+    // Send the message back
+    rc = genlmsg_reply(reply_skb, info);
+    // same as genlmsg_unicast(genl_info_net(info), reply_skb, info->snd_portid)
+    // see https://elixir.bootlin.com/linux/v5.8.9/source/include/net/genetlink.h#L326
+
+    if (rc != 0) {
+        pr_err("An error occurred in %s():\n", __func__);
+        return -rc;
+    }
+    return 0;
+}
+
+/**
+ * Regular ".doit"-callback function if a Generic Netlink with command `GNL_FOOBAR_XMPL_C_REPLY_WITH_NLMSG_ERR` is received.
+ * Please look into the comments where this is used as ".doit" callback above in
+ * `struct genl_ops gnl_foobar_xmpl_ops[]` for more information about ".doit" callbacks.
+*/
+int gnl_cb_doit_reply_with_nlmsg_err(struct sk_buff *sender_skb, struct genl_info *info) {
+    pr_info("%s() invoked, a NLMSG_ERR response will be sent back\n", __func__);
+
+    /*
+     * Generic Netlink is smart enough and sends a NLMSG_ERR reply automatically as reply
+     * Quote from https://lwn.net/Articles/208755/:
+     *  "The 'doit' handler should do whatever processing is necessary and return
+     *   zero on success, or a negative value on failure.  Negative return values
+     *   will cause a NLMSG_ERROR message to be sent while a zero return value will
+     *   only cause a NLMSG_ERROR message to be sent if the request is received with
+     *   the NLM_F_ACK flag set."
+     *
+     * You can find this in Linux code here:
+     * https://elixir.bootlin.com/linux/v5.11/source/net/netlink/af_netlink.c#L2499
+     *
+     * One can find more information about NLMSG_ERROR responses and how to handle them
+     * in userland in the manpage: https://man7.org/linux/man-pages/man7/netlink.7.html
+     */
+    return -EINVAL;
+}
+
+
+
+/** -----  NETLINK Driver defintion ------------------*/
+
+
+
+
+
+/**
+ * callback that is called after the copro send data
+ * we have to copy it in a buffer for the netlink and later send it back to the userland
+ * 
+*/
+static int vrpmdv_monitoring_cb(struct rpmsg_device *rpdev, void *data, int len,
+						void *priv, u32 src)
+{
+	int ret = 0;
+	struct instance_data *idata = dev_get_drvdata(&rpdev->dev);
+
+	dev_info(&rpdev->dev, "incoming msg %d (src: 0x%x)\n",
+		 ++idata->rx_count, src);
+
+	print_hex_dump_debug(__func__, DUMP_PREFIX_NONE, 16, 1, data, len,
+			     true);
+
+    vrpmdv_mon.receive_queue_flag= DATARECEIVED;
+    wake_up_interruptible(&(vrpmdv_mon.receive_queue));
+
+	// /* samples should not live forever */
+	// if (idata->rx_count >= count) {
+	// 	dev_info(&rpdev->dev, "goodbye!\n");
+	// 	return 0;
+	// }
+
+	/* send a new message now */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret)
+	// 	dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
+
+	return ret;
+}
+
+static int vrpmdv_monitoring_probe(struct rpmsg_device *rpdev)
+{
+    int rc;	
+
+	// int ret;
+	// struct instance_data *idata;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+					rpdev->src, rpdev->dst);
+
+	// idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
+	// if (!idata)
+	// 	return -ENOMEM;
+
+	// dev_set_drvdata(&rpdev->dev, idata);
+
+	// /* send a message to our remote processor to */
+	// ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
+	// if (ret) {
+	// 	dev_err(&rpdev->dev, "vrpmdv_monitoring_controler_send failed: %d\n", ret);
+	// 	return ret;
+	// }
+
+	// return 0;
+
+	// struct device *dev;
+    // dev = &rpdev->dev;
+	// struct rpmsg_vrpmdv_mon_t *rpmsg_vrpmdv_mon;
+
+	// rpmsg_vrpmdv_mon = devm_kzalloc(dev, sizeof(*rpmsg_vrpmdv_mon), GFP_KERNEL);
+	// if (!rpmsg_vrpmdv_mon)
+	// 	return -ENOMEM;
+
+    mutex_init(&(vrpmdv_mon.sendMTX));
+    init_waitqueue_head (&(vrpmdv_mon.receive_queue));    
+	vrpmdv_mon.rpdev = rpdev;
+
+	// dev_set_drvdata(&rpdev->dev, rpmsg_vrpmdv_mon);
+    pr_info("RPMSG CMD Device set.\n");
+
+
+	/** NEU **/
+    // if (cmd_cb_progress_data.rpdev == NULL) {
+     // cmd_cb_progress_data.rpdev = rpdev;
+     // pr_info("RPMSG CMD Device set.\n");
+    // }
+    // else {
+    //     pr_info("Error: RPMSG CMD Device already set. Don't set it twice\n");        
+    // }
+
+    pr_info("Generic Netlink VRPMDV-Monitroring_Controler Module started.\n");
+
+    // Register family with its operations and policies
+    rc = genl_register_family(&gnl_vrpmdv_mcmd_family);
+    if (rc != 0) {
+        pr_err("FAILED: genl_register_family(): %i\n", rc);
+        pr_err("An error occurred while inserting the generic netlink example module\n");
+        return -1;
+    } else {
+        pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    return 0;
+
+
+
+}
+
+static void vrpmdv_monitoring_remove(struct rpmsg_device *rpdev)
+{
+    int ret;
+    pr_info("Generic Netlink Example Module unloaded.\n");
+
+    // Unregister the family
+    ret = genl_unregister_family(&gnl_vrpmdv_mcmd_family);
+    if (ret != 0) {
+        pr_err("genl_unregister_family() failed: %i\n", ret);
+        return;
+    } else {
+        pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+    }
+
+    mutex_destroy(&(vrpmdv_mon.sendMTX));
+    wake_up_interruptible(&(vrpmdv_mon.receive_queue));
+	
+	dev_info(&rpdev->dev, "vrpmdv-monitoring controler driver is removed\n");
+
+}
+
+static struct rpmsg_device_id vrpmdv_monitoring_controler_id_table[] = {
+	{ .name	= "vrpmdv-monitoring-controler" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, vrpmdv_monitoring_controler_id_table);
+
+static struct rpmsg_driver vrpmdv_monitoring_controler = {
+	.drv.name	= KBUILD_MODNAME,
+	.id_table	= vrpmdv_monitoring_controler_id_table,
+	.probe		= vrpmdv_monitoring_probe,
+	.callback	= vrpmdv_monitoring_cb,
+	.remove		= vrpmdv_monitoring_remove,
+};
+module_rpmsg_driver(vrpmdv_monitoring_controler);
+
+
+// static struct rpmsg_driver vrpmdv_monitoring_data = {
+// 	.drv.name	= KBUILD_MODNAME,
+// 	.id_table	= vrpmdv_monitoring_controler_id_table,
+// 	.probe		= vrpmdv_monitoring_probe,
+// 	.callback	= vrpmdv_monitoring_cb,
+// 	.remove		= vrpmdv_monitoring_remove,
+// };
+
+// module_rpmsg_driver(vrpmdv_monitoring_data);
+
+MODULE_DESCRIPTION("Remote processor messaging vrpmdv monitoring controler");
+MODULE_LICENSE("GPL v2");
+
+
+
+// /**
+//  * Module/driver initializer. Called on module load/insertion.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static int __init gnl_foobar_xmpl_module_init(void) {
+//     int rc;
+//     pr_info("Generic Netlink Example Module inserted.\n");
+
+//     // Register family with its operations and policies
+//     rc = genl_register_family(&gnl_foobar_xmpl_family);
+//     if (rc != 0) {
+//         pr_err("FAILED: genl_register_family(): %i\n", rc);
+//         pr_err("An error occurred while inserting the generic netlink example module\n");
+//         return -1;
+//     } else {
+//         pr_info("successfully registered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_init(&dumpit_cb_progress_data.mtx);
+
+//     return 0;
+// }
+
+// /**
+//  * Module/driver uninitializer. Called on module unload/removal.
+//  *
+//  * @return success (0) or error code.
+//  */
+// static void __exit gnl_foobar_xmpl_module_exit(void) {
+//     int ret;
+//     pr_info("Generic Netlink Example Module unloaded.\n");
+
+//     // Unregister the family
+//     ret = genl_unregister_family(&gnl_foobar_xmpl_family);
+//     if (ret != 0) {
+//         pr_err("genl_unregister_family() failed: %i\n", ret);
+//         return;
+//     } else {
+//         pr_info("successfully unregistered custom Netlink family '" FAMILY_NAME "' using Generic Netlink.\n");
+//     }
+
+//     mutex_destroy(&dumpit_cb_progress_data.mtx);
+// }
+
+
+// ----
+
+// static int __init rpmsg_sdb_drv_init(void)
+// {
+// 	int ret = 0;
+
+// 	/* Register rpmsg device */
+// 	ret = register_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+
+// 	if (ret) {
+// 		pr_err("rpmsg_sdb(ERROR): Failed to register device\n");
+// 		return ret;
+// 	}
+
+// 	pr_info("rpmsg_sdb: Init done\n");
+
+// 	return ret;
+// }
+
+// static void __exit rpmsg_sdb_drv_exit(void)
+// {
+// 	unregister_rpmsg_driver(&rpmsg_sdb_rmpsg_drv);
+// 	pr_info("rpmsg_sdb: Exit\n");
+// }
+
+// module_init(rpmsg_sdb_drv_init);
+// module_exit(rpmsg_sdb_drv_exit);

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/vrpmdv-monitoring-driver copy.bb.old

@@ -0,0 +1,24 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "CLOSED"
+# LICENSE = "GPL-2.0-only"
+# LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://stm32_rpmsg_sdb.c \
+          "
+# file://75-rpmsg-sdb.rules \
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+# do_install:append() {
+    # udev rules for rpmsg-sdb
+    # install -d ${D}${sysconfdir}/udev/rules.d/
+    # install -m 0644 ${WORKDIR}/75-rpmsg-sdb.rules ${D}${sysconfdir}/udev/rules.d/75-rpmsg-sdb.rules
+# }
+#FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring-driver"

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/vrpmdv-monitoring-driver copy1.bb.old

@@ -0,0 +1,26 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+           file://75-vrpmdv-monitoring.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for vrpmdv-monitoring
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-vrpmdv-monitoring.rules ${D}${sysconfdir}/udev/rules.d/75-vrpmdv-monitoring.rules
+}
+
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/save/vrpmdv-monitoring-driverv2.bb.old

@@ -0,0 +1,26 @@
+SUMMARY = "VRPMDV Monitoring Driver"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring.c \
+           file://75-vrpmdv-monitoring.rules \           
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+do_install:append() {
+    # udev rules for vrpmdv-monitoring
+    install -d ${D}${sysconfdir}/udev/rules.d/
+    install -m 0644 ${WORKDIR}/75-vrpmdv-monitoring.rules ${D}${sysconfdir}/udev/rules.d/75-vrpmdv-monitoring.rules
+}
+
+FILES:${PN} += "${sysconfdir}/udev/rules.d/"
+FILES:${PN} += "${base_libdir}/modules/"
+
+RPROVIDES:${PN} += "vrpmdv-monitoring"

recipes-vrpmdv/recipes-base/vrpmdv-monitoring-controler/vrpmdv-monitoring-controler.bb

@@ -0,0 +1,17 @@
+SUMMARY = "VRPMDV Monitoring Controler"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
+
+inherit module
+
+SRC_URI = "file://Makefile \
+           file://vrpmdv-monitoring-controler.c \
+          "
+
+S = "${WORKDIR}"
+
+# The inherit of module.bbclass will automatically name module packages with
+# "kernel-module-" prefix as required by the oe-core build environment.
+
+
+RPROVIDES:${PN} += "kernel-module-vrpmdv-monitoring-controler"

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/CMakeLists.txt

@@ -0,0 +1,59 @@
+
+cmake_minimum_required(VERSION 3.5)
+#set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+#SET(CMAKE_SYSTEM_PROCESSOR arm)
+#SET(CMAKE_CROSSCOMPILING 1)
+
+project(RTService)
+
+# set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY")
+# set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
+# set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+# set(CMAKE_C_COMPILER_WORKS 1) 
+
+
+# set(CMAKE_FIND_PACKAGE_PREFER_CONFIG ON)
+ set(CMAKE_CXX_STANDARD 17)
+ set(CMAKE_CXX_STANDARD_REQUIRED ON)
+ set(CMAKE_CXX_EXTENSIONS OFF)
+
+# SET(CMAKE_SYSTEM_PROCESSOR arm)
+# SET(CMAKE_CROSSCOMPILING 1)
+
+
+# set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+# set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+# set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+
+
+ set(GCC_COMPILE_FLAGS "-Wall -Wextra -Werror -Wsuggest-override -Wno-register -Wno-missing-braces -Wno-unknown-pragmas -fdiagnostics-show-option")
+
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COMPILE_FLAGS}")
+
+# Find python and Boost - both are required dependencies
+find_package(Boost)
+
+set(source_files
+
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/RTService.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/monitoringTask/RTSMonitoringTask.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/utilities/RTSCoproHelper.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/RTSMonFrame.h
+
+)
+
+add_executable(${PROJECT_NAME} ${source_files})
+
+
+#file( GLOB LIB_SOURCES .src/*.cpp )
+#file( GLOB LIB_HEADERS lib/*.h )
+
+# target_link_libraries(RTService 
+#	PRIVATE
+#		Boost 
+#)cd 
+#target_include_directories(${PROJECT_NAME} PRIVATE ${RTSERVICEINCLUDE})
+
+install(TARGETS RTService DESTINATION bin)

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/.gitignore

@@ -0,0 +1,4 @@
+/CMakeCache.txt
+/Makefile
+/RTService
+/cmake_install.cmake

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/.gitignore

@@ -0,0 +1,7 @@
+/CMakeDirectoryInformation.cmake
+/CMakeOutput.log
+/Makefile.cmake
+/Makefile2
+/TargetDirectories.txt
+/cmake.check_cache
+/progress.marks

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/3.25.2/.gitignore

@@ -0,0 +1,5 @@
+/CMakeCCompiler.cmake
+/CMakeCXXCompiler.cmake
+/CMakeDetermineCompilerABI_C.bin
+/CMakeDetermineCompilerABI_CXX.bin
+/CMakeSystem.cmake

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/3.25.2/CompilerIdC/.gitignore

@@ -0,0 +1,2 @@
+/CMakeCCompilerId.c
+/a.out

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/3.25.2/CompilerIdCXX/.gitignore

@@ -0,0 +1,2 @@
+/CMakeCXXCompilerId.cpp
+/a.out

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/RTService.dir/.gitignore

@@ -0,0 +1,10 @@
+/DependInfo.cmake
+/build.make
+/cmake_clean.cmake
+/compiler_depend.internal
+/compiler_depend.make
+/compiler_depend.ts
+/depend.make
+/flags.make
+/link.txt
+/progress.make

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/RTService.dir/src/.gitignore

@@ -0,0 +1,2 @@
+/RTService.cpp.o
+/RTService.cpp.o.d

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/RTService.dir/src/monitoringTask/.gitignore

@@ -0,0 +1,2 @@
+/RTSMonitoringTask.cpp.o
+/RTSMonitoringTask.cpp.o.d

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/_build/CMakeFiles/RTService.dir/src/utilities/.gitignore

@@ -0,0 +1,2 @@
+/RTSCoproHelper.cpp.o
+/RTSCoproHelper.cpp.o.d

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/include/RTSCoproHelper.h

@@ -0,0 +1,37 @@
+/*
+*/
+
+#include <string>
+
+
+class RTSCoproHelper
+{
+private:
+    /* data */
+    //lock Element
+    int mFdRpmsg[2] = {-1, -1};
+
+public:
+    
+    RTSCoproHelper(/* args */);   
+    ~RTSCoproHelper();
+   
+   int Init(std::string fwPath, std::string fwName);
+
+   int Copro_isFwRunning(void);
+   
+   int Copro_openTtyRpmsg(int ttyNb, int modeRaw);
+   int Copro_closeTtyRpmsg(int ttyNb);
+   int Copro_writeTtyRpmsg(int ttyNb, int len, char* pData);
+   int Copro_readTtyRpmsg(int ttyNb, int len, char* pData);
+   int Copro_stopFw(void);
+   int Copro_startFw(void);
+
+private:
+
+   int Copro_getFwPath(char* pathStr);
+   int Copro_setFwPath(const char* pathStr);
+   int Copro_getFwName(char* pathStr);
+   int Copro_setFwName(const char* nameStr);
+
+};

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/include/RTSMonFrame.h

@@ -0,0 +1,72 @@
+/*
+*/
+
+#include <string>
+#include <list>
+
+
+class RTSMonFrame
+{
+private:
+    /* data */
+    int id;
+    std::string name;
+    int samplerate;
+    int sampleperiod;
+    int downtime;
+    std::string status;
+    std::list<std::string> items;
+
+public:
+    
+   RTSMonFrame(int id, std::string name, int samplerate, int sampleperiod, int downtime, std::string status) {
+    this->id = id;
+    this->name = name;
+    this->samplerate = samplerate;
+    this->sampleperiod = sampleperiod;
+    this->downtime = downtime;
+    this->status = status;
+   }
+   
+   RTSMonFrame(int id) {
+    this->id = id;
+   }
+
+   RTSMonFrame(RTSMonFrame& rtsMonFrameCopy) {
+    this->id = rtsMonFrameCopy.GetId();
+   } 
+
+   ~RTSMonFrame();
+
+   void Add(std::string item){
+    this->items.push_back(item);
+   }
+   int GetId() {
+    return this->id;
+   }
+
+   std::string GetName() {
+    return this->name;
+   }
+ 
+   int GetSampleRate() {
+    return this->samplerate;
+   }
+
+   int GetSamplePeriod(){
+    return this->sampleperiod;
+   }
+   
+   int GetDownTime(){
+    return this->downtime;
+   }
+
+   std::string Gettatus() {
+    return this->status;
+   }
+   
+   std::list<std::string>& GetItems() {
+    return this->items;
+   }
+
+};

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/include/RTSMonitoringTask.h

@@ -0,0 +1,42 @@
+/*
+*/
+#include "RTSCoproHelper.h"
+#include "RTSMonFrame.h"
+#include <pthread.h>
+#include <map>
+#include <string>
+
+
+
+
+class RTSMonitoringTask
+{
+private:
+    /* data */
+    //lock Element
+
+    /* The file descriptor used to manage our TTY over RPMSG */
+    int mFdRpmsg[2] = {-1, -1};
+    RTSCoproHelper coproHelper;
+
+    std::map<int, RTSMonFrame*> rtsMonFrames;
+
+    pthread_t monThread;
+
+public:
+
+    RTSMonitoringTask(/* args */);       
+    ~RTSMonitoringTask();
+
+    //static RTSMonitoringTask& Instance();
+    bool Init();
+    bool CreateMonitoring(int id, std::string name, int samplerate, int sampleperiod, int downtime, std::string status);
+    bool LoadFW();
+    bool Start(); 
+    bool Stop();
+
+private: 
+    static void* Run(void *obj);
+    bool Load();
+
+};

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/include/json_fwd.hpp

@@ -0,0 +1,176 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+/// a class to store JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+         class CustomBaseClass = void>
+class basic_json;
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer;
+
+/*!
+@brief default specialization
+@sa https://json.nlohmann.me/api/json/
+*/
+using json = basic_json<>;
+
+/// @brief a minimal map-like container that preserves insertion order
+/// @sa https://json.nlohmann.me/api/ordered_map/
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/// @brief specialization that maintains the insertion order of object keys
+/// @sa https://json.nlohmann.me/api/ordered_json/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/src/RTService.cpp

@@ -0,0 +1,23 @@
+#include "../include/RTSMonitoringTask.h"
+#include <chrono>
+#include <thread>
+
+
+
+int main([[maybe_unused]] int argc, [[maybe_unused]] char **argv) {
+    
+    RTSMonitoringTask rtMon;
+
+    if (rtMon.Init()) {
+    // idle
+        while(1)
+        {
+            rtMon.CreateMonitoring(1, "Test1", 3750, 2, 10, "stopped");
+            // sleep 100 ms
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    }
+    return 0;
+}
+
+

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/src/monitoringTask/RTSMonitoringTask.cpp

@@ -0,0 +1,104 @@
+/*
+*/
+
+#include "../../include/RTSMonitoringTask.h"
+//#include "../../include/json.hpp"//((
+//#include "../../include/json_fwd.hpp"
+#include <string>
+#include<iostream>
+#include<cstring>
+
+
+
+
+RTSMonitoringTask::RTSMonitoringTask(/* args */)
+{
+}
+
+
+
+
+RTSMonitoringTask::~RTSMonitoringTask()
+{
+}
+
+bool RTSMonitoringTask::Load() {
+    //later load the file
+    int id = 1;
+    RTSMonFrame* rtsMonFrame = new RTSMonFrame(id, "Monitoring1", 3750, 1, 4, "started");
+    rtsMonFrames[id]= rtsMonFrame;
+    return true;
+}
+
+bool RTSMonitoringTask::Init() {
+    
+    //load the Monitorings
+    if (this->Load()) {
+        printf("CA7 : Monitorings loaded\n");
+    }
+    const std::string fwPath = "home/root/elffile";
+    const std::string fwName = "zephyr_openamp_rsc_table.elf";
+
+    //check if the FWIsRunning
+    if (coproHelper.Init(fwPath, fwName) >= 0) {
+        printf("CA7 : Init success \n");
+
+        // if (pthread_create( &monThread, NULL, &RTSMonitoringTask::Run, this) == 0) {
+        //     printf("CA7 : virtual_tty_thread creation fails\n");
+        //     return true;
+        // }
+        return true;
+    }
+    printf("CA7 : starting of Zephyr.elf fails\n");
+    return false;
+}
+
+
+bool RTSMonitoringTask::CreateMonitoring(int id, std::string name, int samplerate, int sampleperiod, int downtime, std::string status){    
+    this->rtsMonFrames[id] = new RTSMonFrame(id, name, samplerate, sampleperiod, downtime, status);
+    char * ch = new char[name.length() + 1];
+
+    // Copying the value of the string into the character array.
+    strcpy(ch, name.c_str());
+
+    this->coproHelper.Copro_writeTtyRpmsg(0,name.length()+1, ch);
+
+    return true;
+}
+
+
+void* RTSMonitoringTask::Run(void *obj) {
+
+    RTSMonitoringTask* rtsMonTask = static_cast<RTSMonitoringTask*>(obj); 
+    std::string newItem;
+    while (1) {
+        // genrate data
+        int i = 1;
+        newItem = "New Item"; //new std::string("New Item:  ").concat(new std::string(i));
+        i++;
+        std::map<int, RTSMonFrame*> rtsMonFrame = rtsMonTask->rtsMonFrames;
+        if (rtsMonFrame.size() > 0) {
+            RTSMonFrame* prtsMonFrame = rtsMonFrame.begin()->second;
+
+            prtsMonFrame->Add(newItem);
+            if (i == 200) {
+                //make a dictonary for the rtsMonFrame id, samplerate, sampleperiod, downtime
+                // boost::python::dict rtsMonFrameDict;
+                // rtsMonFrameDict["id"] = prtsMonFrame->GetId();
+                // rtsMonFrameDict["samplerate"] = prtsMonFrame->GetSampleRate();
+                // rtsMonFrameDict["sampleperiod"] = prtsMonFrame->GetSamplePeriod();                
+                // rtsMonFrameDict["downtime"] = prtsMonFrame->GetDownTime();
+                // //make a dictonary for the sampleItems 
+                // boost::python::list rtsMonItemsList;     
+                // auto items = prtsMonFrame->GetItems();           
+                // for (auto iter = items.begin(); iter!= items.end(); ++iter)
+                // {
+                //    rtsMonItemsList.append(*iter);
+                // }
+                // rtsMonFrameDict["items"]= rtsMonItemsList;
+                // rtsMonTask->callback();
+
+            }
+        }
+    }
+}

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/src/utilities/RTSCoproHelper.cpp

@@ -0,0 +1,347 @@
+/*
+*/
+
+#include "../../include/RTSCoproHelper.h"
+#include <signal.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <time.h>
+#include <pthread.h>
+#include <unistd.h> // for usleep
+#include <math.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/eventfd.h>
+#include <sys/poll.h>
+#include <regex.h>
+#include <sched.h>
+#include <assert.h>
+#include <errno.h>
+#include <error.h>
+
+
+
+#define MAX_BUF 80
+
+#define TTY_CTRL_OPTS (CS8 | CLOCAL | CREAD)
+#define TTY_INPUT_OPTS IGNPAR
+#define TTY_OUTPUT_OPTS 0
+#define TTY_LOCAL_OPTS 0
+
+#define CMDCHANNEL 0
+#define DATACHANNEL 1
+
+RTSCoproHelper::RTSCoproHelper(/* args */)
+{
+}
+
+
+
+
+RTSCoproHelper::~RTSCoproHelper()
+{
+}
+
+int RTSCoproHelper::Init(std::string fwPath, std::string fwName) {
+    int res = -1;
+
+    if (this->Copro_isFwRunning() != 0){
+        //copro is already Runnibng nothing TODO
+        //res = this->Copro_openTtyRpmsg(CMDCHANNEL, 0);       
+        this->Copro_stopFw();
+        //return res;
+        //return 0;
+    }
+
+    //load Firmware    
+    //set firmware path
+    res = this->Copro_setFwPath(fwPath.c_str());     
+    if (res >= 0) {
+        printf("CA7 : Success setting the fwpath, res=%d\n", res);                
+        res = this->Copro_setFwName(fwName.c_str());
+        if (res >= 0) {
+            printf("CA7 : Success setting the fwname, res=%d\n", res);                            
+            res = this->Copro_startFw();
+            if (res >= 0) {
+                printf("CA7 : Success starting Copro, err=%d\n", res);
+                res = this->Copro_openTtyRpmsg(CMDCHANNEL, 1);
+                if (res >= 0 ){
+                    printf("CA7 : Success opening Cmdchannel, err=%d\n", res);                    
+
+                }
+                else {
+                    printf("CA7 : Error opening Cmdchannel, err=%d\n", res);                                        
+                }
+            }
+            else {
+                printf("CA7 : Error could not start the firmware, res=-%d\n", res);                                
+            }
+        }
+        else {
+            printf("CA7 : Error setting the fwName, err=-%d\n", res);        
+        }
+    }
+    else {
+        printf("CA7 : Error setting the fwpath, err=-%d\n", res);        
+    }
+    return res;
+}   
+
+
+/********************************************************************************
+Copro functions allowing to manage a virtual TTY over RPMSG
+*********************************************************************************/
+int RTSCoproHelper::Copro_isFwRunning(void)
+{
+    int fd;
+    size_t byte_read;
+    bool result = 0;
+    unsigned char bufRead[MAX_BUF];
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root", 4)) {
+    //     system("XTERM=xterm su root -c 'cat /sys/class/remoteproc/remoteproc0/state' > /tmp/remoteproc0_state");
+    //     fd = open("/tmp/remoteproc0_state", O_RDONLY);
+    // } else {
+        fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDONLY);
+    // }
+    if (fd < 0) {
+        printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    byte_read = (size_t) read (fd, bufRead, MAX_BUF);
+    if (byte_read >= strlen("running")) {
+        char* pos = strstr((char*)bufRead, "running");
+        if(pos) {
+            result = 1;
+        }
+    }
+    close(fd);
+    return result;
+}
+
+int RTSCoproHelper::Copro_stopFw(void)
+{
+    int fd;
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root",4)) {
+    //     system("su root -c 'echo stop > /sys/class/remoteproc/remoteproc0/state'");
+    //     return 0;
+    // }
+    fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDWR);
+    if (fd < 0) {
+        printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    write(fd, "stop", strlen("stop"));
+    close(fd);
+    return 0;
+}
+ 
+int RTSCoproHelper::Copro_startFw(void)
+{
+    int fd;
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root",4)) {
+    //     system("su root -c 'echo start > /sys/class/remoteproc/remoteproc0/state'");
+    //     return 0;
+    // }
+    fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDWR);
+    if (fd < 0) {
+        printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    write(fd, "start", strlen("start"));
+    close(fd);
+    return 0;
+}
+ 
+int RTSCoproHelper::Copro_getFwPath(char* pathStr)
+{
+    int fd;
+    int byte_read;
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root",4)) {
+    //     system("XTERM=xterm su root -c 'cat /sys/module/firmware_class/parameters/path' > /tmp/parameters_path");
+    //     fd = open("/tmp/parameters_path", O_RDONLY);
+    // } else {
+        fd = open("/sys/module/firmware_class/parameters/path", O_RDONLY);
+    // }
+    if (fd < 0) {
+        printf("CA7 : Error opening firmware_class/parameters/path, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    byte_read = read (fd, pathStr, MAX_BUF);
+    close(fd);
+    return byte_read;
+}
+
+int RTSCoproHelper::Copro_setFwPath(const char* pathStr)
+{
+    int fd;
+    int result = 0;
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root",4)) {
+    //     char cmd[1024];
+    //     snprintf(cmd, 1024, "echo %s > /sys/module/firmware_class/parameters/path", pathStr);
+    //     //snprintf(cmd, 1024, "su root -c 'echo %s > /sys/module/firmware_class/parameters/path'", pathStr);
+    //     system(cmd);
+    //     return strlen(pathStr);
+    // }
+    fd = open("/sys/module/firmware_class/parameters/path", O_RDWR);
+    if (fd < 0) {
+        printf("CA7 : Error opening firmware_class/parameters/path, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    result = write(fd, pathStr, strlen(pathStr));
+    close(fd);
+    return result;
+}
+ 
+int RTSCoproHelper::Copro_getFwName(char* pathStr)
+{
+    int fd;
+    int byte_read;
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root",4)) {
+    //     system("XTERM=xterm su root -c 'cat /sys/class/remoteproc/remoteproc0/firmware' > /tmp/remoteproc0_firmware");
+    //     fd = open("/tmp/remoteproc0_firmware", O_RDONLY);
+    // } else {
+        fd = open("/sys/class/remoteproc/remoteproc0/firmware", O_RDWR);
+    // }
+    if (fd < 0) {
+        printf("CA7 : Error opening remoteproc0/firmware, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    byte_read = read (fd, pathStr, MAX_BUF);
+    close(fd);
+    return byte_read;
+}
+ 
+int RTSCoproHelper::Copro_setFwName(const char* nameStr)
+{
+    int fd;
+    int result = 0;
+    // char *user  = getenv("USER");
+    // if (user && strncmp(user, "root",4)) {
+    //     char cmd[1024];
+    //     snprintf(cmd, 1024, "su root -c 'echo %s > /sys/class/remoteproc/remoteproc0/firmware'", nameStr);
+    //     system(cmd);
+    //     return strlen(nameStr);
+    // }
+    fd = open("/sys/class/remoteproc/remoteproc0/firmware", O_RDWR);
+    if (fd < 0) {
+        printf("CA7 : Error opening remoteproc0/firmware, err=-%d\n", errno);
+        return (errno * -1);
+    }
+    result = write(fd, nameStr, strlen(nameStr));
+    close(fd);
+    return result;
+}
+ 
+int RTSCoproHelper::Copro_openTtyRpmsg(int ttyNb, [[maybe_unused]]int modeRaw)
+{
+
+    //struct termios tiorpmsg;
+    char devName[50];
+    sprintf(devName, "/dev/ttyRPMSG%d", ttyNb%2);
+    mFdRpmsg[ttyNb%2] = open(devName, O_RDWR |  O_NOCTTY | O_NONBLOCK);
+//    mFdRpmsg[ttyNb%2] = open("rpmsg-client-sample", O_RDWR |  O_NOCTTY | O_NONBLOCK);    
+    if (mFdRpmsg[ttyNb%2] < 0) {
+        printf("CA7 : Error opening ttyRPMSG%d, err=-%d\n", ttyNb%2, errno);
+        return (errno * -1);
+    }
+    printf("CA7 : Success opening ttyRPMSG%d \n", ttyNb%2);
+// #if 1
+//     /* get current port settings */
+//     tcgetattr(mFdRpmsg[ttyNb%2],&tiorpmsg);
+//     if (modeRaw) {
+// #if 0
+//         tiorpmsg.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
+//                       | INLCR | IGNCR | ICRNL | IXON);
+//         tiorpmsg.c_oflag &= ~OPOST;
+//         tiorpmsg.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+//         tiorpmsg.c_cflag &= ~(CSIZE | PARENB);
+//         tiorpmsg.c_cflag |= CS8;
+// #else
+//         memset(&tiorpmsg, 0, sizeof(tiorpmsg));
+//         tiorpmsg.c_cflag = TTY_CTRL_OPTS;
+//         tiorpmsg.c_iflag = TTY_INPUT_OPTS;
+//         tiorpmsg.c_oflag = TTY_OUTPUT_OPTS;
+//         tiorpmsg.c_lflag = TTY_LOCAL_OPTS;
+//         tiorpmsg.c_cc[VTIME] = 0;
+//         tiorpmsg.c_cc[VMIN] = 1;
+//         cfmakeraw(&tiorpmsg);
+// #endif
+//     } else {
+//         /* ECHO off, other bits unchanged */
+//         tiorpmsg.c_lflag &= ~ECHO;
+//         /*do not convert LF to CR LF */
+//         tiorpmsg.c_oflag &= ~ONLCR;
+//     }
+//     if (tcsetattr(mFdRpmsg[ttyNb%2], TCSANOW, &tiorpmsg) < 0) {
+//         printf("Error %d in copro_openTtyRpmsg(%d) tcsetattr\n", errno, ttyNb);
+//         return (errno * -1);
+//     }
+// #endif
+    return 0;
+}
+ 
+int RTSCoproHelper::Copro_closeTtyRpmsg(int ttyNb)
+{
+    close(mFdRpmsg[ttyNb%2]);
+    mFdRpmsg[ttyNb%2] = -1;
+    return 0;
+}
+ 
+int RTSCoproHelper::Copro_writeTtyRpmsg(int ttyNb, int len, char* pData)
+{
+    int result = 0;
+    if (mFdRpmsg[ttyNb%2] < 0) {
+        printf("CA7 : Error writing ttyRPMSG%d, fileDescriptor is not set\n", ttyNb%2);
+        return mFdRpmsg[ttyNb%2];
+    }
+ 
+    result = write(mFdRpmsg[ttyNb%2], pData, len);
+    if (result >= 0) {
+        printf("CA7 : Succes writing ttyRPMSG%d, result=%d\n", ttyNb%2, result);    
+    }
+    else {
+        printf("CA7 : Error writing ttyRPMSG%d, err=-%d\n", ttyNb%2, result);    
+    }
+
+    return result;
+}
+ 
+int RTSCoproHelper::Copro_readTtyRpmsg(int ttyNb, int len, char* pData)
+{
+    int byte_rd, byte_avail;
+    int result = 0;
+    if (mFdRpmsg[ttyNb%2] < 0) {
+        printf("CA7 : Error reading ttyRPMSG%d, fileDescriptor is not set\n", ttyNb%2);
+        return mFdRpmsg[ttyNb%2];
+    }
+    ioctl(mFdRpmsg[ttyNb%2], FIONREAD, &byte_avail);
+    if (byte_avail > 0) {
+        if (byte_avail >= len) {
+            byte_rd = read (mFdRpmsg[ttyNb%2], pData, len);
+        } else {
+            byte_rd = read (mFdRpmsg[ttyNb%2], pData, byte_avail);
+        }
+        //printf("CA7 : read successfully %d bytes to %p, [0]=0x%x\n", byte_rd, pData, pData[0]);
+        result = byte_rd;
+    } else {
+        result = 0;
+    }
+    return result;
+}
+/********************************************************************************
+End of Copro functions
+*********************************************************************************/

recipes-vrpmdv/recipes-base/vrpmdv-rtservice/vrpmdv-rtservice.bb

@@ -0,0 +1,49 @@
+SUMMARY = "vrpmdv-rtservice recipe"
+DESCRIPTION = "Recipe to add vrpmdv-setup-page to it's location."
+LICENSE = "CLOSED"
+# LICENSE_FLAGS = "commercial"
+
+# inherit allarch perlnative
+inherit cmake
+
+# DEPENDS += "perl"
+DEPENDS += "boost"
+
+FILESEXTRAPATHS:prepend := "${THISDIR}/files:"
+
+
+SRC_URI += " \
+    file://CMakeLists.txt \
+    file://zephyr_openamp_rsc_table.elf \
+    file://src/RTService.cpp \
+    file://src/monitoringTask/RTSMonitoringTask.cpp \            
+    file://src/utilities/RTSCoproHelper.cpp \            
+    file://include/RTSCoproHelper.h \
+    file://include/RTSMonFrame.h \
+    file://include/RTSMonitoringTask.h \        
+"
+
+
+S = "${WORKDIR}"
+
+# ELFDESTINATION = "~/elffile"
+
+
+# FILES:${PN} += "${DESTINATION}"
+
+# do_install () {
+#    install -d ${D}${ELFDESTINATION}
+#    install -m 0644 ${WORKDIR}/*.elf ${D}/${ELFDESTINATION}     
+#    
+#}
+
+# RDEPENDS:${PN} += " perl"
+# RDEPENDS:${PN} += " boost"
+
+BBCLASSEXTEND = "native "
+# BBCLASSEXTEND = "native nativesdk"
+
+# EXTRA_OECMAKE += "-DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY"
+# EXTRA_OECMAKE += "-DSYSTEM_PROCESSOR=arm"
+# EXTRA_OECMAKE += "-DCROSSCOMPILING=1"
+# EXTRA_OECMAKE = "-DBUILD_TESTING=OFF"