Skip to content

Conversation

@LazarRazvan
Copy link

Course presents F5/F6 keys as shortcuts to move between multiple
results but they are not implemented (not working).

"If there are more than one results (usually there are) you can
move between them using F6 and F5"
cscope_shortcuts.zip

@KernelPRBot
Copy link

Hi @LazarRazvan!

Thanks for your contribution to the Linux kernel!

Linux kernel development happens on mailing lists, rather than on GitHub - this GitHub repository is a read-only mirror that isn't used for accepting contributions. So that your change can become part of Linux, please email it to us as a patch.

Sending patches isn't quite as simple as sending a pull request, but fortunately it is a well documented process.

Here's what to do:

  • Format your contribution according to kernel requirements
  • Decide who to send your contribution to
  • Set up your system to send your contribution as an email
  • Send your contribution and wait for feedback

How do I format my contribution?

The Linux kernel community is notoriously picky about how contributions are formatted and sent. Fortunately, they have documented their expectations.

Firstly, all contributions need to be formatted as patches. A patch is a plain text document showing the change you want to make to the code, and documenting why it is a good idea.

You can create patches with git format-patch.

Secondly, patches need 'commit messages', which is the human-friendly documentation explaining what the change is and why it's necessary.

Thirdly, changes have some technical requirements. There is a Linux kernel coding style, and there are licensing requirements you need to comply with.

Both of these are documented in the Submitting Patches documentation that is part of the kernel.

Note that you will almost certainly have to modify your existing git commits to satisfy these requirements. Don't worry: there are many guides on the internet for doing this.

Who do I send my contribution to?

The Linux kernel is composed of a number of subsystems. These subsystems are maintained by different people, and have different mailing lists where they discuss proposed changes.

If you don't already know what subsystem your change belongs to, the get_maintainer.pl script in the kernel source can help you.

get_maintainer.pl will take the patch or patches you created in the previous step, and tell you who is responsible for them, and what mailing lists are used. You can also take a look at the MAINTAINERS file by hand.

Make sure that your list of recipients includes a mailing list. If you can't find a more specific mailing list, then LKML - the Linux Kernel Mailing List - is the place to send your patches.

It's not usually necessary to subscribe to the mailing list before you send the patches, but if you're interested in kernel development, subscribing to a subsystem mailing list is a good idea. (At this point, you probably don't need to subscribe to LKML - it is a very high traffic list with about a thousand messages per day, which is often not useful for beginners.)

How do I send my contribution?

Use git send-email, which will ensure that your patches are formatted in the standard manner. In order to use git send-email, you'll need to configure git to use your SMTP email server.

For more information about using git send-email, look at the Git documentation or type git help send-email. There are a number of useful guides and tutorials about git send-email that can be found on the internet.

How do I get help if I'm stuck?

Firstly, don't get discouraged! There are an enormous number of resources on the internet, and many kernel developers who would like to see you succeed.

Many issues - especially about how to use certain tools - can be resolved by using your favourite internet search engine.

If you can't find an answer, there are a few places you can turn:

If you get really, really stuck, you could try the owners of this bot, @daxtens and @ajdlinux. Please be aware that we do have full-time jobs, so we are almost certainly the slowest way to get answers!

I sent my patch - now what?

You wait.

You can check that your email has been received by checking the mailing list archives for the mailing list you sent your patch to. Messages may not be received instantly, so be patient. Kernel developers are generally very busy people, so it may take a few weeks before your patch is looked at.

Then, you keep waiting. Three things may happen:

  • You might get a response to your email. Often these will be comments, which may require you to make changes to your patch, or explain why your way is the best way. You should respond to these comments, and you may need to submit another revision of your patch to address the issues raised.
  • Your patch might be merged into the subsystem tree. Code that becomes part of Linux isn't merged into the main repository straight away - it first goes into the subsystem tree, which is managed by the subsystem maintainer. It is then batched up with a number of other changes sent to Linus for inclusion. (This process is described in some detail in the kernel development process guide).
  • Your patch might be ignored completely. This happens sometimes - don't take it personally. Here's what to do:
    • Wait a bit more - patches often take several weeks to get a response; more if they were sent at a busy time.
    • Kernel developers often silently ignore patches that break the rules. Check for obvious violations of the Submitting Patches guidelines, the style guidelines, and any other documentation you can find about your subsystem. Check that you're sending your patch to the right place.
    • Try again later. When you resend it, don't add angry commentary, as that will get your patch ignored. It might also get you silently blacklisted.

Further information

Happy hacking!

This message was posted by a bot - if you have any questions or suggestions, please talk to my owners, @ajdlinux and @daxtens, or raise an issue at https://github.com/ajdlinux/KernelPRBot.

@LazarRazvan LazarRazvan reopened this Feb 23, 2019
@tavip tavip force-pushed the master branch 2 times, most recently from 3e02110 to eb99417 Compare March 2, 2020 16:46
@techonsa
Copy link

techonsa commented Mar 2, 2020

Hi

My apologies if commenting here is incorrect and if so please direct me to the correct place to ask about this problem. My Raspberry Pi 3 wireless is not working properly after upgrade to Buster and rpi-update to latest firmware. Is it a kernel modules issue? Where does the rpi-update command download from?

@tavip tavip force-pushed the master branch 2 times, most recently from 95d15fd to bd336b3 Compare March 3, 2020 06:46
tavip and others added 22 commits February 8, 2021 21:30
Signed-off-by: Octavian Purdila <tavi@cs.pub.ro>
As soon as the lock is unlocked in task_info_find_pid,
the caller cannot be sure if the pointer that is returned is valid.
As long as the returned pointer is used, the lock must be held.

In the case of task_info_add_to_list, the lock that must be held is a writer lock,
in case of a reader lock other readers could read an inconsistent state of the struct task_info.
Starting from kernel version 4.10, `bio_set_op_attrs` is marked as
obsolete. The recommended action is to directly assign the `bio_opf`
field of the `struct bio`.

Code extract from `/include/linux/blk_types.h` (v4.19):
```c
/* obsolete, don't use in new code */
static inline void bio_set_op_attrs(struct bio *bio, unsigned op,
		unsigned op_flags)
{
	bio->bi_opf = op | op_flags;
}
```

Signed-off-by: Horia Ion <horiapaulion@gmail.com>
`minfs_write_inode` should fill the disk inode with the aquired `uid` and `gid` from the inode, not the other way round.

Please check the `minix` solution below:
https://elixir.bootlin.com/linux/latest/source/fs/minix/inode.c#L557
This fixes errors during the "Install native dependencies" step for
building documentation.

Signed-off-by: Octavian Purdila <tavi@cs.pub.ro>
For the `makedev` macro in newer versions of Glibc (since v2.28) we need
to directly include <sys/sysmacros.h>, because that is no longer
included by <sys/types.h>.

Fix by including the correct header.

Signed-off-by: Paul-Stelian Olaru <paul_stelian.olaru@stud.acs.upb.ro>
Up until this commit only core-image-miminal-* Yocto image files were
ignored.  Others, such as core-image-sato-* Yocto image files were not.
This commit fixes that, will al Yocto image files being ignored.

Signed-off-by: Razvan Deaconescu <razvan.deaconescu@cs.pub.ro>
Signed-off-by: Sergiu Weisz <sergiu121@gmail.com>
Signed-off-by: Sergiu Weisz <sergiu121@gmail.com>
For 5-pitix assignment there is no info about score or the number of test passed (at least a counter). Simple searching for "failed" in output is error prone (and painfully hard for the average Joe).

A simple solution is to add a test_ok var to count the number of passed test. Better solutions exist, but keep it simple stupid as fellow student only care about the number of tests passed to know the homework is okay.
 - Change TODO numbering to match code template
 - Fix and improve testing instructions
… ditaa diagrams

Signed-off-by: Octavian Purdila <tavi@cs.pub.ro>
`$` should be used with normal shell commands, while `#` should be used for root commands.

`ls` commands on /dev/* doesn't usually require root access.
dragosargint and others added 28 commits May 2, 2023 22:48
The checker for the uart assignment failed because this module
was compiled for a kernel with a different config.
This is a recompiled version with the current kernel config.

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
    * Previously, if a test failed, all the tests in the batch
    were considered failed. Now we increased the granularity of
    the checker and each test has its own score.
    * If a solution doesn't implement read/write, the checker
    might block. We added a new process to the checker that kills
    such blocked processes.
    * Make the checker output partial results in the form
    [points_per_test/total_points]

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
    * Change the checker output for a single test:
    [points_per_test/points_per_test] => [points_per_test/total_points]

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
Signed-off-by: Costin Sin <sin.costinrobert@gmail.com>
Use dates for feedback form for the 2022-2023 semester.

Signed-off-by: Razvan Deaconescu <razvan.deaconescu@upb.ro>
- Correct base address of module in kernel oops debugging example
- Reference current file containing description of page fault error code bits

Signed-off-by: Macdonald Umoren <macdonald.umoren@proton.me>
errno-base.h and errno.h are now located at include/uapi/asm-generic/

Signed-off-by: Macdonald Umoren <macdonald.umoren@proton.me>
Signed-off-by: Nguyen Dinh Phi <phind.uet@gmail.com>
* Add reference to so2-labs gitlab repo
* Change `make boot` to `make console`

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
	* Update Assignment 0 deadline for 2024

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
	* Add page about the General Rules of the discipline and Grading

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
            * Update Assignment 1 deadline for 2024

Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
The default action on Fedora and RHEL-based distributions that use
FirewallD is to ban DHCP requests. Instead of telling people to turn off
their firewall, I recommend adding the tap interfaces to the FirewallD
trusted zone.

This commit adds automatic support to the create_net.sh and
cleanup-net.sh scripts that set up the tap interfaces. Due to many
distributions using FirewallD these days, I opted for using the
following command to check if FirewallD is available:

if [ -e $(which --skip-alias firewall-cmd) ]; then
    sudo firewall-cmd --zone=trusted --change-interface=$device
fi

However, we will have to create a better solution for this in the
future.

Signed-off-by: Frey Alfredsson <freysteinn@freysteinn.com>
Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
Signed-off-by: Dragoș-Iulian ARGINT <dragosargint21@gmail.com>
Provide working link with TCP connection establishment diagram
intel-lab-lkp pushed a commit to intel-lab-lkp/linux that referenced this pull request Sep 5, 2025
During async unlink, we drop the `i_nlink` counter before we receive
the completion (that will eventually update the `i_nlink`) because "we
assume that the unlink will succeed".  That is not a bad idea, but it
races against deletions by other clients (or against the completion of
our own unlink) and can lead to an underrun which emits a WARNING like
this one:

 WARNING: CPU: 85 PID: 25093 at fs/inode.c:407 drop_nlink+0x50/0x68
 Modules linked in:
 CPU: 85 UID: 3221252029 PID: 25093 Comm: php-cgi8.1 Not tainted 6.14.11-cm4all1-ampere torvalds#655
 Hardware name: Supermicro ARS-110M-NR/R12SPD-A, BIOS 1.1b 10/17/2023
 pstate: 60400009 (nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)
 pc : drop_nlink+0x50/0x68
 lr : ceph_unlink+0x6c4/0x720
 sp : ffff80012173bc90
 x29: ffff80012173bc90 x28: ffff086d0a45aaf8 x27: ffff0871d0eb5680
 x26: ffff087f2a64a718 x25: 0000020000000180 x24: 0000000061c88647
 x23: 0000000000000002 x22: ffff07ff9236d800 x21: 0000000000001203
 x20: ffff07ff9237b000 x19: ffff088b8296afc0 x18: 00000000f3c93365
 x17: 0000000000070000 x16: ffff08faffcbdfe8 x15: ffff08faffcbdfec
 x14: 0000000000000000 x13: 45445f65645f3037 x12: 34385f6369706f74
 x11: 0000a2653104bb20 x10: ffffd85f26d73290 x9 : ffffd85f25664f94
 x8 : 00000000000000c0 x7 : 0000000000000000 x6 : 0000000000000002
 x5 : 0000000000000081 x4 : 0000000000000481 x3 : 0000000000000000
 x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffff08727d3f91e8
 Call trace:
  drop_nlink+0x50/0x68 (P)
  vfs_unlink+0xb0/0x2e8
  do_unlinkat+0x204/0x288
  __arm64_sys_unlinkat+0x3c/0x80
  invoke_syscall.constprop.0+0x54/0xe8
  do_el0_svc+0xa4/0xc8
  el0_svc+0x18/0x58
  el0t_64_sync_handler+0x104/0x130
  el0t_64_sync+0x154/0x158

In ceph_unlink(), a call to ceph_mdsc_submit_request() submits the
CEPH_MDS_OP_UNLINK to the MDS, but does not wait for completion.

Meanwhile, between this call and the following drop_nlink() call, a
worker thread may process a CEPH_CAP_OP_IMPORT, CEPH_CAP_OP_GRANT or
just a CEPH_MSG_CLIENT_REPLY (the latter of which could be our own
completion).  These will lead to a set_nlink() call, updating the
`i_nlink` counter to the value received from the MDS.  If that new
`i_nlink` value happens to be zero, it is illegal to decrement it
further.  But that is exactly what ceph_unlink() will do then.

The WARNING can be reproduced this way:

1. Force async unlink; only the async code path is affected.  Having
   no real clue about Ceph internals, I was unable to find out why the
   MDS wouldn't give me the "Fxr" capabilities, so I patched
   get_caps_for_async_unlink() to always succeed.

   (Note that the WARNING dump above was found on an unpatched kernel,
   without this kludge - this is not a theoretical bug.)

2. Add a sleep call after ceph_mdsc_submit_request() so the unlink
   completion gets handled by a worker thread before drop_nlink() is
   called.  This guarantees that the `i_nlink` is already zero before
   drop_nlink() runs.

The solution is to skip the counter decrement when it is already zero,
but doing so without a lock is still racy (TOCTOU).  Since
ceph_fill_inode() and handle_cap_grant() both hold the
`ceph_inode_info.i_ceph_lock` spinlock while set_nlink() runs, this
seems like the proper lock to protect the `i_nlink` updates.

I found prior art in NFS and SMB (using `inode.i_lock`) and AFS (using
`afs_vnode.cb_lock`).  All three have the zero check as well.

Fixes: 2ccb454 ("ceph: perform asynchronous unlink if we have sufficient caps")
Cc: stable@vger.kernel.org
Signed-off-by: Max Kellermann <max.kellermann@ionos.com>
@torvalds torvalds closed this Sep 22, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.