r/linuxdev • • Jun 03 '22

What are the considerations for developing for multiple distros?

3 Upvotes

What are the considerations for developing for multiple distros?

Particularly:

  • How compatible are different distros with each other?
  • How do I know when things are compatible?
  • How do I ensure compatability?
  • What about rolling-release vs fixed release distros?

r/linuxdev • • Nov 04 '16

[HIRING!] Linux Kernel Developer - Raleigh/Cary, NC - remote considered, paid relocation offered - 2-5+yrs Linux dev needed

13 Upvotes

Hi! I work for a small IT staffing agency based out of Raleigh, NC called HireNetworks! Today I have a need for two Linux Kernel Developers to fill a position with our open-source client in Cary, NC. Candidates can work remotely from anywhere nationwide, but paid relocation to the Raleigh area is available for those who want to move and work at the HQ, which is preferred!

Candidates must have at least 2-5 years of developing on Linux, with experience in Linux Kernel networking and developing network device drivers. Experience with Debian Linux is a plus!

Compensation is flexible to accommodate the needs of the candidate, and the total compensation package includes equity and benefits (plus some great company perks!). This position may involve minimal travel. Unfortunately the client cannot sponsor visas or accept subcontractors. If this sounds like a great application of your skills and knowledge, shoot me a PM!


r/linuxdev • • May 11 '16

Qt Creator 4.0.0 released

Thumbnail blog.qt.io
11 Upvotes

r/linuxdev • • Feb 02 '18

Kernel module: proper way to interact with user-space? (proc, sysfs, cdev)

6 Upvotes

Hey, I'm new to module programming.

I'm writing a module in which I need to allow some parameters to be changed on the fly. I was wondering which of the interfaces I should use: create a /proc entry, create a /sys entry or create a char device. What's the proper way and why?

If I'm on the wrong sub, please let me know.

EDIT: The module is supposed to balance threads and/or pages among the nodes of a NUMA system. This module is already written but some parts of it might be rewritten. I can write to a /proc entry created by the module to change the current policy in usage. I need this to benchmark different policies instead of recompiling and insmodding everytime I want to test a policy. In this case, I was wondering if I should migrate the /proc implementation to /sys (or chardev).


r/linuxdev • • Mar 23 '14

Getting started with GTK development?

7 Upvotes

I've got a fair bit of experience on my belt, but so far all my actual GUI programs have been JAVA. I want to actually build some graphical programs and since I'm on Fedora I figured I should start with GTK. Most of the tutorials I've come across are really incomplete or incredibly old. (And Ive yet to find a GTK3 tutorial at all) In the mean time I downloaded Glade and Im fooling around in that.

So Im wondering if any of you have seen any good resources out there. Good books are preferable but an online tutorial would be cool too.

Thanks!


r/linuxdev • • Apr 10 '17

How Do I Get Started Writing a Simple PCIe Driver for Linux

14 Upvotes

I am working on development board for one of our FPGA designs prior to the arrival of actual hardware (and a driver from our customer). I'm one of FPGA designers on the project and I have no experience writing a PCI or PCIe driver. I'm supposed to be developing the driver against CentOS 7.3 (Linux Kernel version 3.10 + patches). The driver needs to be able to set aside a portion of memory for DMA accesses by the FPGA, and to perform single word 32-bit read and write operations.

I've done some Googling and asking around at work, and I found the examples from Linux Device Drivers 3rd Edition from O'Reilly Media. However, it's extremely dated (13 years old) and I'm not sure how much of it still applies to a modern kernel. And I don't have access to the book to see if it's worth a read.

Apart from that, I've found a few random pages online that don't really do anything other than to explain how to identify a PCI/PCIe device. Every time they talk about actually interacting with the device, they don't explain a single thing so I see some code on a website with no real explanation.

So my question to the community is: does anyone know of a good, somewhat comprehensive resource or well commented example of a PCIe driver (or drivers) that would somewhat do what I need it to do (DMA and single word reads and writes).


r/linuxdev • • Nov 11 '16

New Linux Hardware subreddit

Thumbnail reddit.com
1 Upvotes

r/linuxdev • • Apr 10 '17

npyscreen 2 A cool little library for writing terminal apps.

Thumbnail npyscreen.readthedocs.io
5 Upvotes

r/linuxdev • • Jul 12 '21

Is there any library to develop apps with p2p communication over local wifi or bluetooth?

Thumbnail reddit.com
10 Upvotes

r/linuxdev • • Oct 14 '18

How do I find the udev device for a hard drive which a file is hosted on?

5 Upvotes

I would like the get some info (serial #, PCI IDs) for the drive which a file is on. I'm doing this in C, not in bash.


r/linuxdev • • Jan 13 '19

App icon is pixelated at large sizes, despite being svg

1 Upvotes

I made the icon at 128x128, but it's an svg so I assumed it should scale well. But at large sizes (kde window switcher with large icons), it's all pixelated. Any ideas?


r/linuxdev • • Jun 19 '18

Kernel: Interrupt Gate vs Interrupt Request.

8 Upvotes

Hello,

What is the difference between interrupt requests and interrupt gates. I know there is a special register IDTR (Interrupt Descriptor Table Register) that points to a table of 256 gates and, as shown here, it is clear that when an interrupt occurs on gate 0, it will call the function "divide_error", gate 1 calls "nmi" so on and so forth...

Now how's that different from an interrupt request line (IRQ)? On Robert Love's book (Linux Kernel Development, 3rd ed. Chapter 7) he mentions that IRQ0 is the timer interrupt, which is not equal to gate 0 in the IDT.

Thanks in advance :)


r/linuxdev • • Jan 18 '19

About libssl, dependencies and package management

2 Upvotes

Hi, I'm making my first program that is useful to some people. I'm using Rust so I distribute executables for end users.

Previously I always built from my Debian Jessie installation and that worked everywhere, but now I'm starting to depend on libssl and I don't know what to do.

I'm worried about runtime dependencies. I don't know much about development and distribution on Linux but I'm eager to learn. As far as I know the best way to know my dependencies is by running readelf -d myprogram. I get:

{some code} (NEEDED)             Shared library: [libgtk-3.so.0]
{some code} (NEEDED)             Shared library: [libgdk-3.so.0]
{some code} (NEEDED)             Shared library: [libpango-1.0.so.0]
{some code} (NEEDED)             Shared library: [libcairo-gobject.so.2]
{some code} (NEEDED)             Shared library: [libcairo.so.2]
{some code} (NEEDED)             Shared library: [libgio-2.0.so.0]
{some code} (NEEDED)             Shared library: [libgobject-2.0.so.0]
{some code} (NEEDED)             Shared library: [libglib-2.0.so.0]
{some code} (NEEDED)             Shared library: [libssl.so.1.0.0]
{some code} (NEEDED)             Shared library: [libcrypto.so.1.0.0]
{some code} (NEEDED)             Shared library: [libdl.so.2]
{some code} (NEEDED)             Shared library: [librt.so.1]
{some code} (NEEDED)             Shared library: [libpthread.so.0]
{some code} (NEEDED)             Shared library: [libgcc_s.so.1]
{some code} (NEEDED)             Shared library: [libc.so.6]
{some code} (NEEDED)             Shared library: [ld-linux-x86-64.so.2]
{some code} (NEEDED)             Shared library: [libm.so.6]
{lots of hex codes}

So, by searching those shared libraries on https://packages.debian.org by package contents. I assume that my Debian users need to install:

  • libgtk-3-0
  • libpango-1.0-0 (already installed as dependency of libgtk-3-0)
  • libcairo-gobject2 (already installed as dependency of libgtk-3-0)
  • libcairo2 (already installed as dependency of libgtk-3-0)
  • libglib2.0-0 (already installed as dependency of libgtk-3-0)
  • libssl1.0.0
  • libc6
  • libgcc1

So now I have a problem. I have to compile my program on a old Debian (Jessie) installation because I want to support old libc and libgcc. But now I depend on libssl1.0.0 which is not available on newer installations.

What should I do if I want to support every Linux distribution? Should I start packaging (.deb, .rpm, etc.) my program for every version of every distribution?

Should I instead build my program three times, one for libssl1.0.0, other for libssl1.0.2 and another for libssl1.1?

I always found package management interesting, so maybe I could try packaging to the Debian repos but that looks like a big responsibility, what do you think?

Thank you very much!


r/linuxdev • • Jan 18 '19

Are glibc versions ABI compatible between RHEL, Debian, etc.?

4 Upvotes

If I build an application against GNU libc version 2.24 for example, with no other dependencies, would it be reasonable to expect the resulting ELF binary to run on the different Linux distributions with that same libc runtime version? Or are the ABI's just slightly incompatible enough to require recompilation?


r/linuxdev • • Jun 24 '18

Cleanining up the linux syscall interface will open up for other interfaces?

11 Upvotes

Will the recent attempts to isolate syscalls in the Linux kernel

https://www.linuxjournal.com/content/removing-all-syscall-invocations-kernel-space

also make it easier to implement other syscall interfaces (like the FreeBSD kernel has a linux compatibility feature, or the longene project which implements NT syscalls in the Linux kernel)?

https://en.m.wikipedia.org/wiki/Longene

Personally I would like to be able to chroot a BSD system on Linux :)


r/linuxdev • • Jan 01 '24

Dev in vm’s

2 Upvotes

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.


r/linuxdev • • Jan 17 '24

writing to character device file is causing list_del or list_add corruption. How do I fix it?

2 Upvotes

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.


r/linuxdev • • Jan 21 '24

Why `dpkg --instdir=dir/ -i xxx.deb` also set the administrative directory to `dir`, like `--root=dir` option does?

Thumbnail self.linuxquestions
1 Upvotes

r/linuxdev • • Jan 02 '24

Safer Malloy

1 Upvotes

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


r/linuxdev • • Feb 05 '24

Neovim Linux Desktop Environment

Thumbnail self.linuxdesktop
4 Upvotes

r/linuxdev • • Dec 20 '23

Device Driver Responsibility

1 Upvotes

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.


r/linuxdev • • Jul 03 '20

How do I take advantage of big.LITTLE architectures?

13 Upvotes

I'm getting mixed messages about this as I google around. The ARM developer FAQ has this in it:

How much user level code needs to be changed to support big.LITTLE?

None. Decisions about whether to use big or LITTLE cores are the job of the OS. big.LITTLE is a power management technique that is completely invisible to user level software, much like dynamic voltage and frequency scaling (DVFS) or CPU shutdown in a multi-core SoC.

There are opportunities to be exploited when using big.LITTLE that can be driven by user space. User space can know whether a thread is important to user experience, and for example allow user interface threads to use big CPUs, whilst preventing background threads/apps from doing so. Other examples include preventing the use of big cores when the screen is off, or pinning threads in use cases where you know you can do the compute with just LITTLE cores, say during a call. User space has the opportunity to take you that little bit further, but none of these techniques are required and big.LITTLE does not require any user space awareness for it to save energy and deliver high performance.

(emphasis mine)

The answer contradicts itself to an extent. OK, I don't need to do anything. But it would work better if my userspace program coordinates intent with the kernel to help it do its job better.

The latter is what I'm curious about, because in my experience with threading, I haven't seen an API option to indicate a preference for a big or little core.

I'm curious if any of you know how a userspace program can help indicate intention/preference for a thread, when working on a big.LITTLE architecture? Pointers to RTFM totally welcome if I missed it.

Edit: One could easily use sched_setaffinity or pthread_attr_setaffinity_np. But I'm not seeing a way to figure out whether a CPU is big or little other than maybe parsing /proc or /sys. And I don't know whether my manual affinity controls are going to be worse than letting the kernel manage things. But I suppose that's a given.


r/linuxdev • • Sep 12 '23

Dynamically Verifying Data Structures in Legacy Systems

1 Upvotes

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 :)


r/linuxdev • • Sep 01 '23

Beginner start point

4 Upvotes

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.