January 2016 - kernelnewbies@kernelnewbies.org

How to handle Hotplug with UIO userspace driver
by Mandeep Sandhu Sept. 28, 2017

Sept. 28, 2017

Hi All, We're working on a custom PCIe based hardware, which can be hotplugged into the system. We're using the UIO approach of having a minimal kernel driver which basically handles the interrupt and provides a mmap of the device memory to userspace and userspace driver which mmap's the provided memory and manages the device. We're using systemd and udev rules to spawn off a user process whenever the hardware is plugged into the system. Now my question is, how can we gracefully inform the userspace process if someone pulls out the hardware (sitting on a PCI slot). Even with full hotplug support, there can always be a case of "surprise removal", where someone yanks the board without going through the whole "attention button" routine. While the kernel driver has no problem with hot-removal, I see that if I "unregister" our UIO driver in response to the removal, then the mapping for the hardware's physical memory would become "invalid" (done by UIO on unregsiter). This could possibly cause the user-space process to crash due to illegal memory access. Is there a "standard" way to handle this scenario, i.e for hotpluggable hardware using UIO? Basically, we'd want to "unregister" the UIO device only after the userspace process is informed of the removal so that it could unmap/close the device and exit gracefully. We could try doing it using some systemd trick, where we put a dependency on one of the UIO created files (/dev/uioX), so that when the file is destroyed, systemd could kill/shutdown the process. Although, there's no guarantee that the userspace process won't try to access the mmaped space during that interval, so this isn't a reliable solution either. Any hints, thoughts? Thanks., -mandeep

3 7

What are need to makes humidifier?
by 윤영석 April 1, 2017

April 1, 2017

Hi, I want to make own humidifier. What sensor need when making humidifier?? humidity indicator (detecting humidity), ultrasonic waves maker?? Please shares your wisdom to me. Thanks. Best regards.

2 1

swap test for cgroups
by Kevin Wilson Feb. 1, 2016

Feb. 1, 2016

Hi, I had tried to perform the following test according to: http://lxr.free-electrons.com/source/Documentation/cgroups/memcg_test.txt#L… mkdir /sys/fs/cgroup/memory/group1 echo $$ > /sys/fs/cgroup/memory/group1/cgroup.procs echo 40M > /sys/fs/cgroup/memory/group1/memory.limit_in_bytes Run a process which is a very short program, allocating 100MB: int main() { // Allocate 100 MB void *mem = malloc(1024*1024*100); if (mem) printf("malloc is ok\n"); pause(); } VmSize seems a bit larger than 100MB, and this seems ok, when adding the overhead of running a process: cat /proc/$$/status | grep VmSize VmSize: 116920 kB cat /sys/fs/cgroup/memory/group1/memory.stat | grep swap swap 0 total_swap 0 cat /proc/$$/status | grep -i swap VmSwap: 0 kB I would expect that the swap will be 60M according to the link to the memcg_test.txt mentioned earlier. Any ideas ? Regards, Kevin

2 1

Free electrons course wii nunchuk and BBB i2c connection DTS
by Okash Khawaja Jan. 31, 2016

Jan. 31, 2016

Hi, In this free-electrons course http://free-electrons.com/training/kernel/ it talks about setting up i2c between beagle bone black and nintendo wii nunchuk with UEXT connector. To do that I created the DTS which I have put at the end of this email. It doesn't seem to be working. When I send some bytes to the device which is on i2c1, I get "omap_i2c 4802a000.i2c: timeout waiting for bus ready" message. Feel free to ask details. Any help will be appreciated. Thanks, Okash /dts-v1/; #include "am33xx.dtsi" #include "am335x-bone-common.dtsi" / { model = "TI AM335x BeagleBone Black"; compatible = "ti,am335x-bone-black", "ti,am335x-bone", "ti,am33xx"; }; &i2c1 { status = "okay"; clock-frequency = <100000>; nunchuk@52 { compatible = "nintendo,nunchuk"; reg = <0x52>; }; }; &am33xx_pinmux { pinctrl-names = "default"; pinctrl-0 = <&i2c1_pins>; i2c1_pins: pinmux_i2c1_pins { pinctrl_single,pins = < 0x158 (PIN_INPUT_PULLUP | MUX_MODE2) /* spi0_d1.i2c1_sda */ 0x15c (PIN_INPUT_PULLUP | MUX_MODE2) /* spi0_cs0.i2c1_scl */ >; }; };

1 0

How does the probe function gets called on a PCI device driver?
by Henrique Montenegro Jan. 30, 2016

Jan. 30, 2016

Hello list, I am reading through the e1000 driver and trying to figure out how the probe function on it gets called. The driver initialization function calls pci_register_driver: ----------------------------------------------------------------------------->8 static struct pci_driver e1000_driver = { .name = e1000_driver_name, .id_table = e1000_pci_tbl, .probe = e1000_probe, .remove = e1000_remove, // ... }; static int __init e1000_init_module(void) { // ... ret = pci_register_driver(&e1000_driver); // ... } ----------------------------------------------------------------------------->8 And pci_register_driver is defined as (on linux/pci.h): ----------------------------------------------------------------------------->8 #define pci_register_driver(driver) \ __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME) ----------------------------------------------------------------------------->8 Function __pci_register_driver is defined as (drivers/pci/pci-driver.c): ----------------------------------------------------------------------------->8 int __pci_register_driver(struct pci_driver *drv, struct module *owner, const char *mod_name) { /* initialize common driver fields */ drv->driver.name = drv->name; drv->driver.bus = &pci_bus_type; drv->driver.owner = owner; drv->driver.mod_name = mod_name; spin_lock_init(&drv->dynids.lock); INIT_LIST_HEAD(&drv->dynids.list); /* register with core */ return driver_register(&drv->driver); } EXPORT_SYMBOL(__pci_register_driver); ----------------------------------------------------------------------------->8 This is the point where I am getting lost. I can't figure out how the Kernel will know about the functions defined in the e1000_driver struct mentioned before, since it does not seem to pass a reference to it anywhere. How does the kernel know where the probe function for this module is in this case? To be honest, for any driver that calls pci_register_driver, how will the kernel know where the probe function is since it does not seem like it is being passed to driver_register? Thanks for the help! Henrique

3 3

Capture packets at 10g interface
by Tarun Batra Jan. 30, 2016

Jan. 30, 2016

Hi All, I have to write a kernel module in which I have to capture packets from 10g nic interface and make a copy of them. I have two options Either use netfilters Either use add dev pack If any options u thing please let me know. Should the module be multi threaded? As I can't compromise with performance. Can I bind kernel threads to specific core? Regards

5 9

No response to first patch, is my patch correct?
by Sushuruth Sadagopan Jan. 26, 2016

Jan. 26, 2016

Hi, I followed the "Write and Submit your first Linux kernel Patch" tutorial by Greg Kroah-Hartman [1] and tried to submit my first (clean up) patch [2]. However, I did not get any response, so I sent it again [3]. Once again, I haven't gotten any response. Am I doing anything wrong, or should I just wait longer? Thanks for your help! Sushuruth [1] https://www.youtube.com/watch?v=LLBrBBImJt4 [2] http://www.spinics.net/lists/linux-driver-devel/msg78749.html [3] http://www.spinics.net/lists/linux-driver-devel/msg78921.html

2 2

Acquiring MSI vector physical address from kernel driver
by Ramon Fried Jan. 25, 2016

Jan. 25, 2016

Hi. I'm currently developing a driver for a new PCIe device. The specific PCIe device includes an embedded DMA engine that can be accessed by the host through the PCI configuration space on specific offset. The DMA engine can trigger a MSI on DMA complete if the physical address of the actual vector is written to it. I did some reading, and if I'm not mistaken, it appears that the kernel writes the physical address to the PCI device configuration space when enabling MSI. I didn't find any API or an easy way of getting that address from the kernel given only the MSI number (ID). I can read it (the PA) back from the PCI configuration space, but it seems wrong, as: 1. The kernel has written this value before, it should know this already. 2. Nobody else has done it (grepped the kernel for that) Am I right in my observations ? Is there a better way to achieve that ? Thanks, Ramon

1 0

Reading network connections for processes in a separate net namespaces from /proc/[pid]/net/tcp|tcp6
by dariusz ostolski Jan. 25, 2016

Jan. 25, 2016

Hello, My name is Darek Ostolski, I'm computer enthusiast and hobbyst (also a developer). If this is incorrect mailing list excuse me and please point to the appropriate place to ask this kind of question. I couldn't find any other more appropriate place. I have a process that is in the separate net namespace (basically a container) and I want to check opened connections for that process. I have a kernel 4.3.3. My experiments showed that this information is available in /proc/[pid]/net/tcp|tcp6 files. For example for a global /proc/net/tcp6 shows following opened ports: root@host:~# cat /proc/net/tcp6 sl local_address remote_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode 0: 00000000000000000000000000000000:01BD 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 22882 1 ffff88040de7b240 100 0 0 10 0 1: 00000000000000000000000000000000:008B 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 22883 1 ffff88040de7a9c0 100 0 0 10 0 2: 00000000000000000000000000000000:0050 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 1214363 1 ffff880077ed9340 100 0 0 10 0 3: 00000000000000000000000000000000:0016 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 21933 1 ffff880400a33140 100 0 0 10 0 4: 00000000000000000000000000000000:445C 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 1000 0 29904 1 ffff880400a32040 100 0 0 10 0 And for a process running in container I have: root@host:~# cat /proc/30518/net/tcp6 sl local_address remote_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode 0: 0000000000000000FFFF00000100007F:1F45 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 1211206 1 ffff880364fcb380 100 0 0 10 0 1: 00000000000000000000000000000000:1F49 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 1215425 1 ffff8802befd0200 100 0 0 10 0 2: 00000000000000000000000000000000:1F90 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 1215421 1 ffff880077ed8240 100 0 0 10 0 So I see that there are opened ports that are not visible on host level but are visible at a container level for example 1F90 -> which is basically 8080. I'd like to ask following questions: 1. Where can I find documentation for /proc/[pid]/net/tcp|tcp6 files? All I could find was documentation about global file(i.e. /proc/net/tcp|tcp6) and there is no information about network namespaces at all (google, stackoverflow, man pages, kernel docs) 2. Could You confirm that in these files I'll see all connections that are specific for a given process even if this process is in separate network namespace? (so I dont have to enter target net/pid namespace to read their global /proc/net/tcp|tcp6 files) 3. I've grep kernel source code and tried to find where /proc/[pid]/net/tcp|tcp6 files are created but I couldn't (I've found functions for global files, maybe they are the same). I'd like to check when these files where introduced (from what kernel version they are available) and if I can confirm my findings directly from kernel sources (that I'll see connections from separate net namespace without actually entering that namespace). This is source code that I've found: http://lxr.free-electrons.com/source/net/ipv4/tcp_ipv4.c?v=4.3#L2261 But as I wrote I don't know how it is related to to files from /proc/[pid]/net/tcp|tcp6 Thank You in advance for your help. -- Regards, Darek

2 3

spi_master->rt member, what changes when you change the priority of spi workers?
by Daniel. Jan. 25, 2016

Jan. 25, 2016

Hi all, I was testing some driver that I have for nRF24L01+. ATM the driver sends a frame a changes from TX to RX the fastest possible. The switching from TX to RX is maded at hard IRQ, the rf_hard_irq() sends one message, two spi_transfers to program the nRF24L01+ to RX. The messages are sended asynchronous and I have two trace_puts() calls to measure the times using FTRACE feature. The kernel version is 3.10.53 running on arm (i.MX6) I've noted that spi_master struct has an rt boolean member which should increace the priority of spi tasks to higher possible. I did that and measure the times, they were about 100us then I removed this and measue again, they were about 75us. Summarazing, increasing the spi workers priority had increased the time that takes to change from TX to RX, remembering that this change is done by sending two spi transfers to the nRF24L01+. I want to understand why I higher priority is decreasing the performance instead of boosting it? Best regards, The code can be viewed here: https://gist.github.com/gkos/f171be307cca71e375a8 -- "Do or do not. There is no try" Yoda Master

1 0