- kernelnewbies@kernelnewbies.org - Kernelnewbies Mailing Lists

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

'bin/sh: can't access tty' when boot from kernel-4.3.3
by Hao Lee Jan. 25, 2016

Jan. 25, 2016

Hi, I encounter a problem when I boot from kernel-4.3.3. I use 'make allnoconfig' to generate an initial config file and use 'make menuconfig' to configure my kernel then compile it. But when I try to boot from my new kernel, I see a message: ' bin/sh: can't access tty; job control turned off '. I have searched some solutions on google, but I can't solve this problem. So, could someone give me some advice or some tips to solve it. Thanks!!! My development environment: CentOS 6.0 with kernel-2.6.32 gcc 4.4.7 binutils 2.20 make 3.81 Regards, Hao Lee

2 1

Re: CFS: Scheduler: How does each change in 'nice' value result in 10% change in CPU time?
by alexander198961 Jan. 23, 2016

Jan. 23, 2016

From m2 -------- Original message -------- Sender: John Locke <jlockefree(a)gmail.com> Time: Thu 1/21 17:53 To: kernelnewbies(a)kernelnewbies.org Subject: CFS: Scheduler: How does each change in 'nice' value result in 10% change in CPU time? >Can anyone explain how the weights that the 'nice' values are mapped >to actually result in an ~10% change in CPU time as you go from one >nice level to the next? I can't make out how the comment here actually >computes: (https://git.kernel.org/cgit/linux/kernel/git/stable/linux-stable.git/tree/k…) > >/* > * Nice levels are multiplicative, with a gentle 10% change for every > * nice level changed. I.e. when a CPU-bound task goes from nice 0 to > * nice 1, it will get ~10% less CPU time than another CPU-bound task > * that remained on nice 0. > * > * The "10% effect" is relative and cumulative: from _any_ nice level, > * if you go up 1 level, it's -10% CPU usage, if you go down 1 level > * it's +10% CPU usage. (to achieve that we use a multiplier of 1.25. > * If a task goes up by ~10% and another task goes down by ~10% then > * the relative distance between them is ~25%.) > */ >static const int prio_to_weight[40] = { > >If I take an example of 2 tasks both with weight=1024 (NICE_0) they >should each get 50% of the CPU time. If 1 of the tasks is reniced to >NICE_1 then the NICE_0 task will get 1024/(1024+820)=56% of the CPU >time and the NICE_1 task will get 44% of the CPU time. I'm obviously >not understanding something since I can't come at those 10% figures in >the comments. > >Thanks. > >_______________________________________________ >Kernelnewbies mailing list >Kernelnewbies(a)kernelnewbies.org >http://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies

1 0