I have a very singular problem; I am trying to make my open-source app work for the Linux people, I would really like to let all developers use it regardless if they are on windows or not, I probably will need to have some kind to native module to solve this, so don't worry much about electron itself.

My app basically shows the screen the mouse is currently on in a multi-screen setup, this means I need to record all screens in order to switch to the proper one in a timely manner.

The issue is that apparently on Linux 22.04 there is Pipewire.

Even by looking at the state of OBS seems like Pipewire is just trash when it comes to having the application programmatically handle the recording of multiple screens, and that the only "gate" to get multiple screens is the permission prompt Ubuntu spawns letting you choose the screen you want to record, and you end up having to spawn it once for every screen and hope the user will choose the right option, at least on my VM setup (virtualbox with multiple screens) looks like OBS cannot remember the screens I set across restarts instead defaulting to the first one, also looking at electron looks like there is no way to have consistent display ids between capturing and screen APIs, though it may be electron's fault.

Is it like I researched already or there is some feature that could allow me to tap in multi-screen recording? also, I need to have a consistent display ID associated with the source in order to tell in which screen the mouse is.

currently I am using electron's screen recording API but I am open to try building some kind of native C/C++ module that may help me to solve this issue.

My last solution is to try a transparent window moving between displays, but first I wanted to see if you guys knew better, dealing with a transparent window may break my ability to make it work independently from which virtual desktop you are on, also OBS is so good on windows that it won't record what is behind a transparent window, instead keeping its transparency and breaking compatibility.

even the option "sudo your way out of it" may be acceptable as last resource, I could theoretically create an external process with elevated permissions that records the screen on-demand and IPC the data to my GUI in a way or another, it would be absolutely awful but still better than nothing.

gabrielesilinic/stage-retriever: Stage Retriever is a way for you to share multiple screens at once to any meeting app, this way you can focus on what you are presenting and you will not have to bring each window to the screen you initially choose to share. (github.com)

I am following LDD3. I have implemented the read and write functionality for the scull module. whenever I run echo hello > /dev/scull0 to test the write function, I get list_add / list_del corruption and a stack trace.

Here is my code:

#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/stat.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/cdev.h>

#define SCULL_DEV_NO 4

MODULE_LICENSE("Dual BSD/GPL");

static int scull_major = 0;
static int scull_minor = 0;
static int scull_nr_devs = 4;
static int scull_qset_val = 1000;
static int scull_quantum_val = 4000;

module_param(scull_major, int, S_IRUGO);

static dev_t dev = 0;

struct scull_qset{
	void **data;
	struct scull_qset * next;
};

struct scull_dev{
	struct cdev cdev;
	struct scull_qset *data;
	int qset;
	unsigned long size;
	int quantum;
	unsigned int access_key;
	struct semaphore sem;
};

int scull_trim(struct scull_dev *dev){
	struct scull_qset *dptr, *next;
	int i;
	int qset =  dev->qset;
	for (dptr = dev->data; dptr; dptr = next){
		if (dptr->data){
			for(i = 0; i < qset; i++){
				kfree(dptr->data[i]);
			}
			kfree(dptr->data);
			dptr->data = NULL;
		}
		next = dptr->next;
		kfree(dptr);
	}

	dev->data = NULL;
	dev->qset = scull_qset_val;
	dev->size = 0;
	dev->quantum = scull_quantum_val;
	return 0;
}

int scull_open(struct inode * inode, struct file * filp){
	struct scull_dev * dev;
	dev = container_of(inode->i_cdev, struct scull_dev, cdev);

	filp->private_data = dev;

	if((filp->f_flags & O_ACCMODE) == O_WRONLY){
		scull_trim(dev);
	}

	printk(KERN_INFO "scull: Opened device %d\n", iminor(inode));

	return 0;
}

int scull_release(struct inode * inode, struct file * filp){
	printk(KERN_INFO "scull: Released device %d\n", iminor(inode));
	return 0;
}

struct scull_qset* scull_follow(struct scull_dev *dev, int item){
	struct scull_qset* ptr = dev->data;
	struct scull_qset* rptr = NULL;

	for(int i=0; i<item+1; i++){
		pr_info("DEBUG: ptr = %p, ptr->next = %p\n", ptr, ptr ? ptr->next : NULL);
		if(ptr == NULL){
			ptr = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
			if (ptr == NULL)
				return NULL;
			memset(ptr, 0, sizeof(struct scull_qset));
			ptr->data = NULL;
			ptr->next = NULL;
		}

		rptr = ptr;
		ptr = ptr->next;
	}

	return rptr;
}

ssize_t scull_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos){
	ssize_t retval = 0;
	struct scull_dev *dev = filp->private_data;
	struct scull_qset *dptr;
	int quantum = dev->quantum, qset = dev->qset;
	int itemsize = quantum * qset;
	int item, s_pos, q_pos, rest;

	if (down_interruptible(&dev->sem))
		return -ERESTARTSYS;
	if (*f_pos >= dev->size)
		goto out;
	if (*f_pos + count > dev->size)
		count = dev->size - *f_pos;

	item = (long)*f_pos / itemsize;
	rest = (long)*f_pos % itemsize;
	s_pos = rest / quantum; q_pos = rest % quantum;

	dptr = scull_follow(dev, item);

	if (dptr == NULL || !dptr->data || !dptr->data[s_pos])
		goto out;

	if (count > quantum - q_pos)
		count = quantum - q_pos;

	if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)){
		return -EFAULT;
		goto out;
	}

	*f_pos += count;
	retval = count;

	out:
		up(&dev->sem);
		return retval;
}

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos){
	struct scull_dev *dev = filp->private_data;
	struct scull_qset *dptr;
	int quantum = dev->quantum, qset = dev->qset;
	int itemsize = quantum * qset;
	int item, s_pos, q_pos, rest;
	ssize_t retval = -ENOMEM;

	if (down_interruptible(&dev->sem))
		return -ERESTARTSYS;

	item = (long)*f_pos / itemsize;
	rest = (long)*f_pos % itemsize;
	s_pos = rest / quantum; q_pos = rest % quantum;

	dptr = scull_follow(dev, item);
	if (dptr == NULL)
		goto out;

	if (!dptr->data){
		dptr->data = kmalloc(sizeof(char *)  * dev->qset, GFP_KERNEL);
		if (!dptr->data)
			goto out;
		memset(dptr->data, 0, qset * sizeof(char *));
	}
	if (!dptr->data[s_pos]){
		dptr->data[s_pos] = kmalloc(dev->quantum, GFP_KERNEL);
		if (!dptr->data[s_pos])
			goto out;
	}

	if (count > quantum - q_pos)
		count = quantum - q_pos;

	if (copy_from_user(dptr->data[s_pos] + q_pos, buf, count)){
		retval = -EFAULT;
		goto out;
	}

	*f_pos += count;
	retval = count;

	if (dev->size < *f_pos)
		dev->size = *f_pos;

	out:
		up(&dev->sem);
		return retval; 
}

static struct scull_dev scull_devp_array[SCULL_DEV_NO];

struct file_operations scull_fops = {
	.owner = THIS_MODULE,
	.open = scull_open,
	.release = scull_release,
	.read = scull_read,
	.write = scull_write
};

static void scull_setup_cdev(struct scull_dev *dev, int index){
	dev_t dev_no = MKDEV(scull_major, scull_minor + index);
	cdev_init(&dev->cdev, &scull_fops);
	dev->cdev.owner = THIS_MODULE;
	printk(KERN_INFO "scull: Initialized Major: %d, Minor: %d\n", scull_major, scull_minor + index);

	int result = cdev_add(&dev->cdev, dev_no, 1);
	if (result < 0){
		printk(KERN_ERR "scull: Failed to add Major: %d, Minor: %d\n", scull_major, scull_minor + index);
	}
}

static void scull_rm_cdev(struct scull_dev *dev){
	printk(KERN_INFO "scull: Removing cdev\n");
	cdev_del(&dev->cdev);
}

static int __init scull_init(void){
	printk(KERN_INFO "scull: Allocating char device...\n");
	
	int result;
	if(scull_major){
		dev = MKDEV(scull_major, scull_minor);
		result = register_chrdev_region(dev, scull_nr_devs, "scull");
	}

	else{
		result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull");
		scull_major = MAJOR(dev);
	}

	if (result < 0){
		printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
		return result;
	}

	printk(KERN_INFO "scull: Major is %d", scull_major);

	for(int i = scull_minor; i < scull_nr_devs; i++){
		scull_setup_cdev(&scull_devp_array[i], i);
	}
	return 0;
}

static void __exit scull_exit(void){
	printk(KERN_INFO "scull: Exiting...\n");
	unregister_chrdev_region(dev, scull_nr_devs);
	printk(KERN_INFO "scull: Unregistered device\n");
	for(int i = scull_minor; i < scull_nr_devs; i++){
		scull_rm_cdev(&scull_devp_array[i]);
		printk(KERN_INFO "scull: Freeing scull_dev %d\n", i);
	}
}

module_init(scull_init);
module_exit(scull_exit);

I ran echo hello > /dev/scull0. The dmesg logs shows list_add corruption. prev is NULL on running the command. When I exit out with Ctrl + C and run the command again, the dmesg logs shows 2 errors, the first being a list_del corruption and the second being a list_add corruption. Here is the dmesg log for the 3 errors:

[43170.630743] scull: Opened device 0
[43170.630761] ------------[ cut here ]------------
[43170.630764] list_add corruption. prev is NULL.
[43170.630773] WARNING: CPU: 6 PID: 57011 at lib/list_debug.c:25 __list_add_valid_or_report+0x42/0xa0
[43170.630784] Modules linked in: scull(OE) ntfs3 snd_seq_dummy snd_hrtimer snd_seq ccm nvidia_drm(POE) nvidia_uvm(POE) nvidia_modeset(POE) nvidia(POE) vfat fat intel_rapl_msr intel_rapl_common edac_mce_amd kvm_amd iwlmvm kvm mac80211 irqbypass mousedev snd_usb_audio joydev crct10dif_pclmul crc32_pclmul polyval_clmulni polyval_generic snd_usbmidi_lib snd_ump snd_hda_codec_realtek snd_rawmidi snd_hda_codec_generic snd_seq_device ledtrig_audio gf128mul snd_hda_codec_hdmi mc ghash_clmulni_intel sha512_ssse3 sha256_ssse3 sha1_ssse3 aesni_intel snd_hda_intel snd_intel_dspcfg snd_intel_sdw_acpi snd_hda_codec libarc4 snd_hda_core btusb btrtl btintel iwlwifi btbcm snd_hwdep btmtk snd_pcm bluetooth cfg80211 snd_timer snd r8169 crypto_simd cryptd ecdh_generic rapl soundcore realtek sp5100_tco mdio_devres k10temp libphy rfkill i2c_piix4 video ccp gigabyte_wmi wmi_bmof pcspkr acpi_cpufreq gpio_amdpt wmi mac_hid gpio_generic i2c_dev crypto_user loop fuse dm_mod nfnetlink ip_tables x_tables ext4 crc32c_generic crc16 mbcache jbd2
[43170.630928]  usbhid nvme nvme_core crc32c_intel xhci_pci xhci_pci_renesas nvme_auth
[43170.630941] Unloaded tainted modules: scull(OE):13 [last unloaded: scull(OE)]
[43170.630951] CPU: 6 PID: 57011 Comm: bash Tainted: P  R   D W  OE      6.7.0-arch3-1 #1 29ada86f174bb9983ea57568622d66509982ed7e
[43170.630957] Hardware name: Gigabyte Technology Co., Ltd. B450M DS3H WIFI/B450M DS3H WIFI-CF, BIOS F52 01/07/2021
[43170.630960] RIP: 0010:__list_add_valid_or_report+0x42/0xa0
[43170.630966] Code: 75 41 4c 8b 02 49 39 c0 75 4c 48 39 fa 74 60 49 39 f8 74 5b b8 01 00 00 00 e9 fa 05 77 00 48 c7 c7 d0 c7 2a 92 e8 fe 24 a5 ff <0f> 0b 31 c0 e9 e5 05 77 00 48 c7 c7 f8 c7 2a 92 e8 e9 24 a5 ff 0f
[43170.630970] RSP: 0018:ffffad82c1e9bcf8 EFLAGS: 00010082
[43170.630975] RAX: 0000000000000000 RBX: 7fffffffffffffff RCX: 0000000000000027
[43170.630979] RDX: ffff89f40e9a16c8 RSI: 0000000000000001 RDI: ffff89f40e9a16c0
[43170.630982] RBP: ffffad82c1e9bd68 R08: 0000000000000000 R09: ffffad82c1e9bb80
[43170.630985] R10: 0000000000000003 R11: ffff89f41f32b368 R12: ffffffffc24b87c8
[43170.630989] R13: 0000000000000001 R14: 0000000000000000 R15: ffffffffc24b87d0
[43170.630992] FS:  00007747f80d6740(0000) GS:ffff89f40e980000(0000) knlGS:0000000000000000
[43170.630997] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[43170.631000] CR2: 0000563ef7be1000 CR3: 00000001c487c000 CR4: 0000000000350ef0
[43170.631004] Call Trace:
[43170.631008]  <TASK>
[43170.631011]  ? __list_add_valid_or_report+0x42/0xa0
[43170.631016]  ? __warn+0x81/0x130
[43170.631025]  ? __list_add_valid_or_report+0x42/0xa0
[43170.631030]  ? report_bug+0x171/0x1a0
[43170.631037]  ? prb_read_valid+0x1b/0x30
[43170.631043]  ? srso_return_thunk+0x5/0x5f
[43170.631050]  ? handle_bug+0x3c/0x80
[43170.631057]  ? exc_invalid_op+0x17/0x70
[43170.631063]  ? asm_exc_invalid_op+0x1a/0x20
[43170.631074]  ? __list_add_valid_or_report+0x42/0xa0
[43170.631080]  ? __list_add_valid_or_report+0x42/0xa0
[43170.631084]  __down_common+0x71/0x230
[43170.631095]  down_interruptible+0x52/0x60
[43170.631101]  scull_write+0x4c/0x200 [scull bd55e810425245067618b333771c8e3ae1dc9535]
[43170.631114]  vfs_write+0xf2/0x400
[43170.631127]  ksys_write+0x6f/0xf0
[43170.631135]  do_syscall_64+0x64/0xe0
[43170.631140]  ? srso_return_thunk+0x5/0x5f
[43170.631145]  ? syscall_exit_to_user_mode+0x2b/0x40
[43170.631150]  ? srso_return_thunk+0x5/0x5f
[43170.631155]  ? do_syscall_64+0x70/0xe0
[43170.631159]  ? srso_return_thunk+0x5/0x5f
[43170.631164]  ? do_syscall_64+0x70/0xe0
[43170.631169]  ? srso_return_thunk+0x5/0x5f
[43170.631174]  ? exc_page_fault+0x7f/0x180
[43170.631180]  entry_SYSCALL_64_after_hwframe+0x6e/0x76
[43170.631186] RIP: 0033:0x7747f8254034
[43170.631209] Code: c7 00 16 00 00 00 b8 ff ff ff ff c3 66 2e 0f 1f 84 00 00 00 00 00 f3 0f 1e fa 80 3d 35 c3 0d 00 00 74 13 b8 01 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 54 c3 0f 1f 00 48 83 ec 28 48 89 54 24 18 48
[43170.631213] RSP: 002b:00007fffe0667af8 EFLAGS: 00000202 ORIG_RAX: 0000000000000001
[43170.631218] RAX: ffffffffffffffda RBX: 0000000000000006 RCX: 00007747f8254034
[43170.631222] RDX: 0000000000000006 RSI: 0000563ef7bde970 RDI: 0000000000000001
[43170.631225] RBP: 0000563ef7bde970 R08: 0000000000000073 R09: 0000000000000001
[43170.631228] R10: 0000000000000000 R11: 0000000000000202 R12: 0000000000000006
[43170.631232] R13: 00007747f83295c0 R14: 00007747f8326f20 R15: 0000000000000000
[43170.631241]  </TASK>
[43170.631244] ---[ end trace 0000000000000000 ]---
[43188.138981] ------------[ cut here ]------------
[43188.138987] list_del corruption, ffffad82c1e9bd10->next is NULL
[43188.138999] WARNING: CPU: 6 PID: 57011 at lib/list_debug.c:52 __list_del_entry_valid_or_report+0x5d/0xe0
[43188.139009] Modules linked in: scull(OE) ntfs3 snd_seq_dummy snd_hrtimer snd_seq ccm nvidia_drm(POE) nvidia_uvm(POE) nvidia_modeset(POE) nvidia(POE) vfat fat intel_rapl_msr intel_rapl_common edac_mce_amd kvm_amd iwlmvm kvm mac80211 irqbypass mousedev snd_usb_audio joydev crct10dif_pclmul crc32_pclmul polyval_clmulni polyval_generic snd_usbmidi_lib snd_ump snd_hda_codec_realtek snd_rawmidi snd_hda_codec_generic snd_seq_device ledtrig_audio gf128mul snd_hda_codec_hdmi mc ghash_clmulni_intel sha512_ssse3 sha256_ssse3 sha1_ssse3 aesni_intel snd_hda_intel snd_intel_dspcfg snd_intel_sdw_acpi snd_hda_codec libarc4 snd_hda_core btusb btrtl btintel iwlwifi btbcm snd_hwdep btmtk snd_pcm bluetooth cfg80211 snd_timer snd r8169 crypto_simd cryptd ecdh_generic rapl soundcore realtek sp5100_tco mdio_devres k10temp libphy rfkill i2c_piix4 video ccp gigabyte_wmi wmi_bmof pcspkr acpi_cpufreq gpio_amdpt wmi mac_hid gpio_generic i2c_dev crypto_user loop fuse dm_mod nfnetlink ip_tables x_tables ext4 crc32c_generic crc16 mbcache jbd2
[43188.139153]  usbhid nvme nvme_core crc32c_intel xhci_pci xhci_pci_renesas nvme_auth
[43188.139166] Unloaded tainted modules: scull(OE):13 [last unloaded: scull(OE)]
[43188.139175] CPU: 6 PID: 57011 Comm: bash Tainted: P  R   D W  OE      6.7.0-arch3-1 #1 29ada86f174bb9983ea57568622d66509982ed7e
[43188.139182] Hardware name: Gigabyte Technology Co., Ltd. B450M DS3H WIFI/B450M DS3H WIFI-CF, BIOS F52 01/07/2021
[43188.139186] RIP: 0010:__list_del_entry_valid_or_report+0x5d/0xe0
[43188.139191] Code: 48 8b 01 48 39 f8 75 67 48 8b 72 08 48 39 c6 75 74 b8 01 00 00 00 e9 32 05 77 00 48 89 fe 48 c7 c7 f8 c8 2a 92 e8 33 24 a5 ff <0f> 0b 31 c0 e9 1a 05 77 00 48 89 fe 48 c7 c7 20 c9 2a 92 e8 1b 24
[43188.139196] RSP: 0018:ffffad82c1e9bcf8 EFLAGS: 00010082
[43188.139200] RAX: 0000000000000000 RBX: 7fffffffffffffff RCX: 0000000000000027
[43188.139204] RDX: ffff89f40e9a16c8 RSI: 0000000000000001 RDI: ffff89f40e9a16c0
[43188.139208] RBP: ffffad82c1e9bd68 R08: 0000000000000000 R09: ffffad82c1e9bb80
[43188.139211] R10: 0000000000000003 R11: ffff89f41f32b368 R12: ffffffffc24b87c8
[43188.139214] R13: 0000000000000001 R14: 0000000000000001 R15: ffff89f270b10000
[43188.139217] FS:  00007747f80d6740(0000) GS:ffff89f40e980000(0000) knlGS:0000000000000000
[43188.139222] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[43188.139225] CR2: 00007740023bd698 CR3: 00000001c487c000 CR4: 0000000000350ef0
[43188.139229] Call Trace:
[43188.139233]  <TASK>
[43188.139236]  ? __list_del_entry_valid_or_report+0x5d/0xe0
[43188.139241]  ? __warn+0x81/0x130
[43188.139248]  ? __list_del_entry_valid_or_report+0x5d/0xe0
[43188.139253]  ? report_bug+0x171/0x1a0
[43188.139261]  ? prb_read_valid+0x1b/0x30
[43188.139267]  ? srso_return_thunk+0x5/0x5f
[43188.139274]  ? handle_bug+0x3c/0x80
[43188.139280]  ? exc_invalid_op+0x17/0x70
[43188.139286]  ? asm_exc_invalid_op+0x1a/0x20
[43188.139298]  ? __list_del_entry_valid_or_report+0x5d/0xe0
[43188.139304]  ? __list_del_entry_valid_or_report+0x5d/0xe0
[43188.139308]  __down_common+0xdb/0x230
[43188.139318]  down_interruptible+0x52/0x60
[43188.139325]  scull_write+0x4c/0x200 [scull bd55e810425245067618b333771c8e3ae1dc9535]
[43188.139338]  vfs_write+0xf2/0x400
[43188.139350]  ksys_write+0x6f/0xf0
[43188.139358]  do_syscall_64+0x64/0xe0
[43188.139363]  ? srso_return_thunk+0x5/0x5f
[43188.139368]  ? syscall_exit_to_user_mode+0x2b/0x40
[43188.139373]  ? srso_return_thunk+0x5/0x5f
[43188.139378]  ? do_syscall_64+0x70/0xe0
[43188.139382]  ? srso_return_thunk+0x5/0x5f
[43188.139387]  ? do_syscall_64+0x70/0xe0
[43188.139392]  ? srso_return_thunk+0x5/0x5f
[43188.139397]  ? exc_page_fault+0x7f/0x180
[43188.139403]  entry_SYSCALL_64_after_hwframe+0x6e/0x76
[43188.139409] RIP: 0033:0x7747f8254034
[43188.139432] Code: c7 00 16 00 00 00 b8 ff ff ff ff c3 66 2e 0f 1f 84 00 00 00 00 00 f3 0f 1e fa 80 3d 35 c3 0d 00 00 74 13 b8 01 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 54 c3 0f 1f 00 48 83 ec 28 48 89 54 24 18 48
[43188.139436] RSP: 002b:00007fffe0667af8 EFLAGS: 00000202 ORIG_RAX: 0000000000000001
[43188.139442] RAX: ffffffffffffffda RBX: 0000000000000006 RCX: 00007747f8254034
[43188.139445] RDX: 0000000000000006 RSI: 0000563ef7bde970 RDI: 0000000000000001
[43188.139448] RBP: 0000563ef7bde970 R08: 0000000000000073 R09: 0000000000000001
[43188.139452] R10: 0000000000000000 R11: 0000000000000202 R12: 0000000000000006
[43188.139455] R13: 00007747f83295c0 R14: 00007747f8326f20 R15: 0000000000000000
[43188.139464]  </TASK>
[43188.139467] ---[ end trace 0000000000000000 ]---
[43188.139503] scull: Released device 0
[43189.594736] scull: Opened device 0
[43189.594753] ------------[ cut here ]------------
[43189.594757] list_add corruption. prev is NULL.
[43189.594766] WARNING: CPU: 6 PID: 57011 at lib/list_debug.c:25 __list_add_valid_or_report+0x42/0xa0
[43189.594777] Modules linked in: scull(OE) ntfs3 snd_seq_dummy snd_hrtimer snd_seq ccm nvidia_drm(POE) nvidia_uvm(POE) nvidia_modeset(POE) nvidia(POE) vfat fat intel_rapl_msr intel_rapl_common edac_mce_amd kvm_amd iwlmvm kvm mac80211 irqbypass mousedev snd_usb_audio joydev crct10dif_pclmul crc32_pclmul polyval_clmulni polyval_generic snd_usbmidi_lib snd_ump snd_hda_codec_realtek snd_rawmidi snd_hda_codec_generic snd_seq_device ledtrig_audio gf128mul snd_hda_codec_hdmi mc ghash_clmulni_intel sha512_ssse3 sha256_ssse3 sha1_ssse3 aesni_intel snd_hda_intel snd_intel_dspcfg snd_intel_sdw_acpi snd_hda_codec libarc4 snd_hda_core btusb btrtl btintel iwlwifi btbcm snd_hwdep btmtk snd_pcm bluetooth cfg80211 snd_timer snd r8169 crypto_simd cryptd ecdh_generic rapl soundcore realtek sp5100_tco mdio_devres k10temp libphy rfkill i2c_piix4 video ccp gigabyte_wmi wmi_bmof pcspkr acpi_cpufreq gpio_amdpt wmi mac_hid gpio_generic i2c_dev crypto_user loop fuse dm_mod nfnetlink ip_tables x_tables ext4 crc32c_generic crc16 mbcache jbd2
[43189.594923]  usbhid nvme nvme_core crc32c_intel xhci_pci xhci_pci_renesas nvme_auth
[43189.594936] Unloaded tainted modules: scull(OE):13 [last unloaded: scull(OE)]
[43189.594945] CPU: 6 PID: 57011 Comm: bash Tainted: P  R   D W  OE      6.7.0-arch3-1 #1 29ada86f174bb9983ea57568622d66509982ed7e
[43189.594951] Hardware name: Gigabyte Technology Co., Ltd. B450M DS3H WIFI/B450M DS3H WIFI-CF, BIOS F52 01/07/2021
[43189.594955] RIP: 0010:__list_add_valid_or_report+0x42/0xa0
[43189.594960] Code: 75 41 4c 8b 02 49 39 c0 75 4c 48 39 fa 74 60 49 39 f8 74 5b b8 01 00 00 00 e9 fa 05 77 00 48 c7 c7 d0 c7 2a 92 e8 fe 24 a5 ff <0f> 0b 31 c0 e9 e5 05 77 00 48 c7 c7 f8 c7 2a 92 e8 e9 24 a5 ff 0f
[43189.594964] RSP: 0018:ffffad82c1e9bd28 EFLAGS: 00010086
[43189.594970] RAX: 0000000000000000 RBX: 7fffffffffffffff RCX: 0000000000000027
[43189.594973] RDX: ffff89f40e9a16c8 RSI: 0000000000000001 RDI: ffff89f40e9a16c0
[43189.594977] RBP: ffffad82c1e9bd98 R08: 0000000000000000 R09: ffffad82c1e9bbb0
[43189.594980] R10: 0000000000000003 R11: ffff89f41f32b368 R12: ffffffffc24b87c8
[43189.594983] R13: 0000000000000001 R14: 0000000000000000 R15: ffffffffc24b87d0
[43189.594987] FS:  00007747f80d6740(0000) GS:ffff89f40e980000(0000) knlGS:0000000000000000
[43189.594991] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[43189.594995] CR2: 00007740023bd698 CR3: 00000001c487c000 CR4: 0000000000350ef0
[43189.594999] Call Trace:
[43189.595003]  <TASK>
[43189.595006]  ? __list_add_valid_or_report+0x42/0xa0
[43189.595011]  ? __warn+0x81/0x130
[43189.595020]  ? __list_add_valid_or_report+0x42/0xa0
[43189.595026]  ? report_bug+0x171/0x1a0
[43189.595033]  ? prb_read_valid+0x1b/0x30
[43189.595038]  ? srso_return_thunk+0x5/0x5f
[43189.595046]  ? handle_bug+0x3c/0x80
[43189.595052]  ? exc_invalid_op+0x17/0x70
[43189.595058]  ? asm_exc_invalid_op+0x1a/0x20
[43189.595069]  ? __list_add_valid_or_report+0x42/0xa0
[43189.595075]  ? __list_add_valid_or_report+0x42/0xa0
[43189.595079]  __down_common+0x71/0x230
[43189.595090]  down_interruptible+0x52/0x60
[43189.595096]  scull_write+0x4c/0x200 [scull bd55e810425245067618b333771c8e3ae1dc9535]
[43189.595109]  vfs_write+0xf2/0x400
[43189.595117]  ? srso_return_thunk+0x5/0x5f
[43189.595122]  ? syscall_exit_to_user_mode+0x2b/0x40
[43189.595127]  ? srso_return_thunk+0x5/0x5f
[43189.595131]  ? do_syscall_64+0x70/0xe0
[43189.595136]  ? srso_return_thunk+0x5/0x5f
[43189.595141]  ? filp_flush+0x52/0x80
[43189.595149]  ksys_write+0x6f/0xf0
[43189.595157]  do_syscall_64+0x64/0xe0
[43189.595162]  ? do_syscall_64+0x70/0xe0
[43189.595166]  ? syscall_exit_to_user_mode+0x2b/0x40
[43189.595171]  ? srso_return_thunk+0x5/0x5f
[43189.595175]  ? do_syscall_64+0x70/0xe0
[43189.595180]  ? srso_return_thunk+0x5/0x5f
[43189.595184]  ? syscall_exit_to_user_mode+0x2b/0x40
[43189.595189]  ? srso_return_thunk+0x5/0x5f
[43189.595194]  ? do_syscall_64+0x70/0xe0
[43189.595199]  entry_SYSCALL_64_after_hwframe+0x6e/0x76
[43189.595205] RIP: 0033:0x7747f8254034
[43189.595228] Code: c7 00 16 00 00 00 b8 ff ff ff ff c3 66 2e 0f 1f 84 00 00 00 00 00 f3 0f 1e fa 80 3d 35 c3 0d 00 00 74 13 b8 01 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 54 c3 0f 1f 00 48 83 ec 28 48 89 54 24 18 48
[43189.595232] RSP: 002b:00007fffe0667af8 EFLAGS: 00000202 ORIG_RAX: 0000000000000001
[43189.595237] RAX: ffffffffffffffda RBX: 0000000000000006 RCX: 00007747f8254034
[43189.595241] RDX: 0000000000000006 RSI: 0000563ef7bde970 RDI: 0000000000000001
[43189.595244] RBP: 0000563ef7bde970 R08: 0000000000000073 R09: 0000000000000001
[43189.595247] R10: 0000000000000000 R11: 0000000000000202 R12: 0000000000000006
[43189.595250] R13: 00007747f83295c0 R14: 00007747f8326f20 R15: 0000000000000000
[43189.595260]  </TASK>
[43189.595263] ---[ end trace 0000000000000000 ]---

I tested to see if it was an issue with the scull_follow function by removing everything in the write function and just using down_interruptible and printk to see if that was the case. I was encountering the same issue. I am hypothesising that the issue has something to do with the semaphore. Please guide me on what to do.

Basically what the title said. I’ve been hearing people on YouTube talking about it, but am unsure how many actually use it

I was wondering if it would be safer to create my own malloc or use the one provided by the compiler

I’m a somewhat beginner at programming and was wondering if it would be better to do all of my programming in a virtual machine or on the host machine.

Are there any best practices or guidelines for where the roles and responsibilities of a Device Driver End?

For example, suppose a network device determines the quality of a link is degraded, and the requirement is to either set the link down or attempt to lower the speed before setting the link down based on a policy set by the user. Are there any guidelines to suggest the implementation of such a policy is to be handled within the device driver itself or rather in user space (possibly in a service)?

The engineer in me knows the answer. That it depends on the requirements. However I wanted to see if anyone knew of guidelines that may be in place. I don’t have any specific problem to solve. Just wanted to see if the roles and responsibilities were clear cut.

Hello, I'm interested in writing a program that can create two files, second file would be a "view" of first file and if modified, the first file would also be modified. Is this possible to do with mmap or at all?

I know that using mmap i can have shared memory in RAM, but I need shared memory in non-volatile memory aka hard drive. I cannot copy the first file or load it fully into RAM since I assume the file can be of very large size (GBs).

After I find how to have the second file showing memory subset of first file I plan to make 3 files, first being container and second and third showing different subsets of the first file. Second and third file are to be formatted with filesystem so that first file container holds in it's memory two filesystems accessible via second and third file. This I plan to accomplish by attaching the second and third files as loopback devices and mounting them.

Is this doable of am I not seeing something?

Hello everyone,

I've been experimenting with Linux Kernel modules, and so far I've written three of them.

An IRQ-based keylogger, a syscall hook on connect() that prints the IP addresses the system connects to, and a netfilter hook that rejects all UDP packets on ports other than 53 and 5085.

Any ideas for something equally or more challenging?

Are you passionate about Linux and Unix? 🐧

Do you want to connect with like-minded individuals, from beginners to experts? 🧠

Then you've found your new home. We're all about fostering meaningful connections and knowledge sharing.

🤔 Why We Exist: At the heart of our community is a shared love for Linux and Unix. We're here to connect with fellow enthusiasts, regardless of where you are on your journey, and create a space where our shared passion thrives.

🤨 How We Do It: We foster a welcoming environment where open conversations are the norm. Here, you can share your experiences, ask questions, and deepen your knowledge alongside others who are equally passionate.

🎯 What We Offer:

🔹 Engaging Discussions: Our discussions revolve around Linux and Unix, creating a hub of knowledge-sharing and collaboration. Share your experiences, ask questions, and learn from each other.

🔹 Supportive Environment: Whether you're a newcomer or a seasoned pro, you'll find your place here. We're all about helping each other grow. Our goal is to create a friendly and supportive space where everyone, regardless of their level of expertise, feels at home.

🔹 Innovative Tools: Explore our bots, including "dlinux," which lets you create containers and run commands without leaving Discord—a game-changer for Linux enthusiasts.

🔹 Distro-Specific Support: Our community is equipped with dedicated support channels for popular Linux distributions, including but not limited to:

Arch Linux

CentOS

Debian

Fedora

Red Hat

Ubuntu

...and many more!

Why Choose Us? 🌐

Our server aligns perfectly with Discord's guidelines and Terms of Service, ensuring a safe and enjoyable experience for all members. 🧐 📜 ✔️

Don't take our word for it—come check it out yourself! 👀

Join our growing community of Linux and Unix enthusiasts today let's explore, learn, and share our love for Linux and Unix together. 🐧❤️

See you on the server! 🚀

https://discord.gg/unixverse

My main machine is an Apple Mac Studio and have been running AArch64 Linux distributions in virtual machines but I need to work on Linux distributions running on x86_64.

Is it possible to create an SSH tunnel between my Mac and the remote Linux machine and use a text editor (VSCode) as if it were just running off the local machine?

I'd rather avoid using something like GitHub Codespaces but I'm curious how it works.

Any help is appreciated.

Hi everyone,

I have a project to develop techniques and build tools that address the issue of property validation in legacy systems using dynamic runtime verification.

The project aims to use formal verification techniques in operating systems to ensure correctness and security. Most existing systems are too complex for traditional formal verification, so the focus is on practical methods, such as runtime verification. They plan to leverage eBPF, a Linux subsystem, to build tools that guarantee specific properties in the kernel with minimal overhead. The initial focus will be on simple data structures like linked lists in user-space applications, with the possibility of extending to more complex structures like hash tables and radix trees if time allows.

I would greatly appreciate it I could get some starting points as well as some resources as I'm really excited for this project!

Thank you so much for your time :)

I wasn't sure where to post this but I thought a Linux specific sub would be better than asking it in a Unity 3d sub, so please bear with me.

I'm working on a game in Unity and I have implemented a custom level editor. This editor supports copy/paste directly to/from the clipboard. For Windows I'm using PInvoke to access the Windows API and it works great. For any other platform I'm currently converting binary data to Base64 and then use Unity's GUIUtility.copySystemBuffer which only supports text. This also works but it floods the text clipboard with unnecessary data and it's not great for the user.

I'm mainly a Windows user but I've used Linux on and off so I plan to fully support Linux as well.

So I started looking into how Linux deals with the clipboard. I found that X11 has its own API but Wayland doesn't, and delegates that responsibility to clipboard managers that I don't know how to properly detect and use in a way that is portable. So in my limited understanding I don't think there's a generic way to interact with the clipboard on Linux, even if I have a different method for X11 and Wayland.

Since it's a custom binary format, the simple solution I thought of will be to simply write the copy data to a specific file in /tmp/ and then read it back when the user pastes, which will also work across different instances of the level editor. In my understanding this place is always safe to write and read for all flavors of Linux, so it can work for me.

My question is, is there a better way? If not, is this solution going to be really portable, or are there any environments that do things differently? Are there any caveats I should know about?

Thank you for your patience if you made it this far.

Hello everyone, I've been using Linux as my main operating system for a few years now, I've also been studying programming for a long time (java, python and currently C). What I would like to know is where I should start to program applications for linux, I don't know if you know of any type of course (it doesn't matter if it is paid) where projects for linux using C are carried out.

Hi I'm definitely not a Linux developer or claim to be anything more than someone that avidly uses Linux but that being said I wanted to ask if anyone has seen anything in the works as far as an AI powered Linux OS or if not how hard someone would think it would be to build a distro with AI built in as well to help users navigate the systems.

As the title states, I am trying to make a init system for linux in rust, but ive hit a sort of roadblock. I have populated /dev and agetty'd a tty but i cant do anything more than type in it, i get the username prompt but it never prompts for anything else and i suspect its a part of initializing the system in contrary to being a rust code problem directly, hence why im asking here. any help at all would be greatly appreciated, my source code is here

I downloaded the source for coreutils and tried to compile it.

I keep getting an error: "parse-datetime.tab.c missing"

I can't figure out why. Is it possible that there is a missing entry in the Makefile?

​

Hello,

So I'm new to this community (not new to Linux, been using Ubuntu and Fedora for quite some time). I was thinking of buying a new laptop in the near future, and I wanted to decide between a Mac and another Thinkpad (the laptop I have currently, and I really liked it), which brings me to my question.

Why would I get a Thinkpad and install Linux, vs getting a Mac which is Unix based to begin with along with having amazing battery life with it's M2 chip (Ignore price as a factor)?

I was looking back through my Linux journey and I've realized that Linux has had multiple problems for me, such as having issues with dual booting, issues with Microphone and Speakers, distros not fitting on screens,Linux and such.

I was also wondering, couldn't you do most of your stuff regarding linux dev in Macs? as well? I wanted to ask what about Linux can you not reproduce without a high amount of effort on macs.

(Also I wanted to ask whether, in terms of security, are macs inherently better than linux).

​

Thank you :)

I've been looking into how I could write some platform code to query running GUI applications and manipulate them (show/hide/close/launch etc.) from code, in a specifically GNOME/KDE agnostic fashion.

The goal being to hook this into a Flutter application for a front-end "streamdeck" interface that could be useful on a Framework screen module.

***

How do I get started with this? I'm not too concerned with x11 support, and nor am I personally against using any particular language (though something like python or rust would be easier to set up an environment for).

Researching what I know about WM and wayland etc. leads me towards writing my own manager/compositor which is explicitly not what I want to do. I want to build this as an application that runs on top of the active desktop environment. I did get a slither of progress querying the running xOrg server, but with the pain that it was developing that solution I'd rather just stick to Wayland.

What is the most interesting UNIX command you've seen or used?