Just a guess, but those numbers look more interesting in hex:

    672274793 = 0x28121969
     85072278 = 0x05121996
    369367448 = 0x16041998
    537993216 = 0x20112000

Developers&#39; or developers&#39; children&#39;s birthdays?

Regarding finding the syscall implementation, I did a `git grep -n LINUX_REBOOT_MAGIC2` and found the definition in kernel/sys.c. The symbol `sys_reboot` is generated by the `SYSCALL_DEFINE4(reboot, ...` gubbins, I suspect.


It&#39;s the birthday of Linus Torvalds (The developer of the Linux kernel and the Git version control) and his 3 daughters. works as magic numbers to reboot the system.

http://en.wikipedia.org/wiki/Linus_Torvalds

I&#39;ve been reading the Python documentation about the subprocess module (see [here][1]) and it talks about a `subprocess.check_output()` command which seems to be exactly what I need.

However, when I try and use it I get an error that it doesn&#39;t exist, and when I run `dir(subprocess)` it is not listed.

I am running Python 2.6.5, and the code I have used is below:

    import subprocess
    subprocess.check_output([&quot;ls&quot;, &quot;-l&quot;, &quot;/dev/null&quot;])

Does anyone have any idea why this is happening?


  [1]: http://docs.python.org/library/subprocess.html#subprocess-replacements

subprocess.check_output() doesn&#39;t seem to exist (Python 2.6.5)

I want to convert `string` `data` to `NSInteger`.

Convert NSString to NSInteger?

[*The Linux Programming Interface*][1] has an exercise in Chapter 3 that goes like this:

&gt; When using the Linux-specific reboot()
&gt; system call to reboot the system, the
&gt; second argument, magic2, must be
&gt; specified as one of a set of magic
&gt; numbers (e.g., LINUX_REBOOT_MAGIC2).
&gt; What is the significance of these
&gt; numbers? (Converting them to
&gt; hexadecimal provides a clue.)

The man page tells us `magic2` can be one of LINUX_REBOOT_MAGIC2 (672274793), LINUX_REBOOT_MAGIC2A (85072278), LINUX_REBOOT_MAGIC2B (369367448), or LINUX_REBOOT_MAGIC2C (537993216). I failed to decipher their meaning in hex. I also looked at `/usr/include/linux/reboot.h`, which didn&#39;t give any helpful comment either.

I then searched in the kernel&#39;s source code for `sys_reboot`&#39;s definition. All I found was a declaration in a header file.

Therefore, my first question is, what is the significance of these numbers? My second question is, where&#39;s `sys_reboot`&#39;s definition, and how did you find it?

**EDIT**: I found the definition in `kernel/sys.c`. I only grepped for `sys_reboot`, and forgot to grep for the MAGIC numbers. I figured the definition must be hidden behind some macro trick, so I looked at the `System.map` file under `/boot`, and found it next to `ctrl_alt_del`. I then grepped for that symbol, which led me to the correct file. If I had compiled the kernel from source code, I could try to find which object file defined the symbol, and go from there.

  [1]: http://man7.org/tlpi/

Magic numbers of the Linux reboot() system call

<a href="http://man7.org/tlpi/" target="_blank" rel="noopener noreferrer">The Linux Programming Interface</a> has an exercise in Chapter 3 that goes like this:
> When using the Linux-specific reboot()
> system call to reboot the system, the
> second argument, magic2, must be
> specified as one of a set of magic
> numbers (e.g., LINUX_REBOOT_MAGIC2).
> What is the significance of these
> numbers? (Converting them to
> hexadecimal provides a clue.)
The man page tells us <code>magic2</code> can be one of LINUX_REBOOT_MAGIC2 (672274793), LINUX_REBOOT_MAGIC2A (85072278), LINUX_REBOOT_MAGIC2B (369367448), or LINUX_REBOOT_MAGIC2C (537993216). I failed to decipher their meaning in hex. I also looked at <code>/usr/include/linux/reboot.h</code>, which didn't give any helpful comment either.
I then searched in the kernel's source code for <code>sys_reboot</code>'s definition. All I found was a declaration in a header file.
Therefore, my first question is, what is the significance of these numbers? My second question is, where's <code>sys_reboot</code>'s definition, and how did you find it?
EDIT: I found the definition in <code>kernel/sys.c</code>. I only grepped for <code>sys_reboot</code>, and forgot to grep for the MAGIC numbers. I figured the definition must be hidden behind some macro trick, so I looked at the <code>System.map</code> file under <code>/boot</code>, and found it next to <code>ctrl_alt_del</code>. I then grepped for that symbol, which led me to the correct file. If I had compiled the kernel from source code, I could try to find which object file defined the symbol, and go from there.

Problem Is: Some SFTP connections are failing in customer environment
             But using sample code if i test with same server no connection is failed.
             may be in customer envi many parallel sftp connection started at a time.

I Want to know what is the meaning of MaxStartups 10:30:60

In the above i know only 10 , which means maximum unauthenticated ssh connection allowed.
means at same time 12 sssh connection request comes 2 request fail and 10 success.

What is the mean of 30 and 60 ?

In SSHD Configuration what does &quot;MaxStartups 10:30:60&quot; mean?

Some background info: I was looking to run a script on a Red Hat server to read some data from /dev/random and use the Perl unpack() command to convert it to a hex string for usage later on (benchmarking database operations).  I ran a few &quot;head -1&quot; on /dev/random and it seemed to be working out fine, but after calling it a few times, it would just kinda hang.  After a few minutes, it would finally output a small block of text, then finish.

I switched to /dev/urandom (I really didn&#39;t want to, its slower and I don&#39;t need that quality of randomness) and it worked fine for the first two or three calls, then it too began hang.
I was wondering if it was the &quot;head&quot; command that was bombing it, so I tried doing some simple I/O using Perl, and it too was hanging.
As a last ditch effort, I used the &quot;dd&quot; command to dump some info out of it directly to a file instead of to the terminal.  All I asked of it was 1mb of data, but it took 3 minutes to get ~400 bytes before I killed it.

I checked the process lists, CPU and memory were basically untouched.  What exactly could cause /dev/random to crap out like this and what can I do to prevent/fix it in the future?


*Edit:* Thanks for the help guys!  It seems that I had random and urandom mixed up.  I&#39;ve got the script up and running now.  Looks like I learned something new today. :)

/dev/random Extremely Slow?

is it possible to specify non-capturing groups in sed?

if so, how?

how do you specify non-capturing groups in sed?

I `screen -r`&#39;d into a Django server that&#39;s running and I can&#39;t simply &lt;kbd&gt;Ctrl&lt;/kbd&gt; + &lt;kbd&gt;C&lt;/kbd&gt; and `exit` out of it.

Are there any alternative ways to get out of `screen`?

Currently, I manually close the tab on my local PC and `ssh` back in, but that&#39;s becoming tiresome.


How do I get out of &#39;screen&#39; without typing &#39;exit&#39;?

Example `file.txt`:

      100 foo
      2 bar
      300 tuu

When using `sort -k 1,1 file.txt`, the order of lines will not change, though we are expecting :

      2 bar
      100 foo
      300 tuu

How to sort a field consisting of numbers based on the absolute numerical value?

How to sort a file, based on its numerical values for a field?

What are the most common and why not uncommon methods and tools used to do live debugging on the Linux kernel? I know that Linus for eg. is [against](http://lwn.net/2000/0914/a/lt-debugger.php3) this kind of debugging for the Linux Kernel or it least was and thus nothing much has been done in that sense in those years, but honestly a lot of time has passed since 2000 and i am interested if that mentality has changed regarding the Linux project and what current methods are used to do live debugging on the Linux kernel at the moment(either local or remote)?

References to walkthroughs and tutorials on mentioned techniques and tools are welcome.

Linux kernel live debugging, how it&#39;s done and what tools are used?

In the linux kernel, what does the `probe()` method, that the driver provides, do? How different is it from the driver&#39;s `init` function, i.e. why can&#39;t the `probe()` functions actions be performed in the driver&#39;s `init` function ?

Why is the probe method needed in Linux device drivers in addition to init?

In [kernel.h][1] min is defined as:

    #define min(x, y) ({				\
    	typeof(x) _min1 = (x);			\
    	typeof(y) _min2 = (y);			\
    	(void) (&amp;_min1 == &amp;_min2);		\
    	_min1 &lt; _min2 ? _min1 : _min2; })

I don&#39;t understand what the line `(void) (&amp;_min1 == &amp;_min2);` does.  Is it some kind of type checking or something?


  [1]: http://lxr.linux.no/linux+*/tools/perf/util/include/linux/kernel.h#L41

What is the function of &quot;(void) (&amp;_min1 == &amp;_min2)&quot; in the min macro in kernel.h?

What is the difference between the kernel space and the user space? Do kernel space, kernel threads, kernel processes and kernel stack mean the same thing? Also, why do we need this differentiation?

What is the difference between the kernel space and the user space?

I am working on this driver that connects the hard disk over the network. There is a bug that if I enable two or more hard disks on the computer, only the first one gets the partitions looked over and identified. The result is, if I have 1 partition on hda and 1 partitions on hdb, as soon as I connect hda there is a partition that can be mounted. So hda1 gets a blkid xyz123 as soon as it mounts. But when I go ahead and mount hdb1 it also comes up with the same blkid and in fact, the driver is reading it from hda, not hdb. 

So I think I found the place where the driver is messing up. Below is a debug output including a dump_stack which I put at the first spot where it seems to be accessing the wrong device. 

Here is the code section:

    /*basically, this is just the request_queue processor. In the log output that
      follows, the second device, (hdb) has just been connected, right after hda
      was connected and hda1 was mounted to the system. */
    
    void nblk_request_proc(struct request_queue *q)
    {
    struct request *req;
    ndas_error_t err = NDAS_OK;
    
	dump_stack();

    while((req = NBLK_NEXT_REQUEST(q)) != NULL)
    {
    	dbgl_blk(8,&quot;processing queue request from slot %d&quot;,SLOT_R(req));
    	
        if (test_bit(NDAS_FLAG_QUEUE_SUSPENDED, &amp;(NDAS_GET_SLOT_DEV(SLOT_R(req))-&gt;queue_flags)))  {
            printk (&quot;ndas: Queue is suspended\n&quot;);
            /* Queue is suspended */
    #if ( LINUX_VERSION_CODE &gt;= KERNEL_VERSION(2,6,31) )
            blk_start_request(req);
    #else
            blkdev_dequeue_request(req);
    #endif


Here is a log output. I have added some comments to help understand what is happening and where the bad call seems to come up. 

      /* Just below here you can see &quot;slot&quot; mentioned many times. This is the 
         identification for the network case in which the hd is connected to the 
         network. So you will see slot 2 in this log because the first device has 
         already been connected and mounted. */
      
      kernel: [231644.155503] BL|4|slot_enable|/driver/block/ctrldev.c:281|adding disk: slot=2, first_minor=16, capacity=976769072|nd/dpcd1,64:15:44.38,3828:10
      kernel: [231644.155588] BL|3|ndop_open|/driver/block/ops.c:233|ing bdev=f6823400|nd/dpcd1,64:15:44.38,3720:10
      kernel: [231644.155598] BL|2|ndop_open|/driver/block/ops.c:247|slot =0x2|nd/dpcd1,64:15:44.38,3720:10
      kernel: [231644.155606] BL|2|ndop_open|/driver/block/ops.c:248|dev_t=0x3c00010|nd/dpcd1,64:15:44.38,3720:10
      kernel: [231644.155615] ND|3|ndas_query_slot|netdisk/nddev.c:791|slot=2 sdev=d33e2080|nd/dpcd1,64:15:44.38,3696:10
      kernel: [231644.155624] ND|3|ndas_query_slot|netdisk/nddev.c:817|ed|nd/dpcd1,64:15:44.38,3696:10
      kernel: [231644.155631] BL|3|ndop_open|/driver/block/ops.c:326|mode=1|nd/dpcd1,64:15:44.38,3720:10
      kernel: [231644.155640] BL|3|ndop_open|/driver/block/ops.c:365|ed open|nd/dpcd1,64:15:44.38,3724:10
      kernel: [231644.155653] BL|8|ndop_revalidate_disk|/driver/block/ops.c:2334|gendisk=c6afd800={major=60,first_minor=16,minors=0x10,disk_name=ndas-44700486-0,private_data=00000002,capacity=%lld}|nd/dpcd1,64:15:44.38,3660:10
      kernel: [231644.155668] BL|8|ndop_revalidate_disk|/driver/block/ops.c:2346|ed|nd/dpcd1,64:15:44.38,3652:10
      
      /* So at this point the hard disk is added (gendisk=c6...) and the identifications
         all match the network device. The driver is now about to begin scanning the 
         hard drive for existing partitions. the little &#39;ed&#39;, at the end of the previous
         line indicates that revalidate_disk has finished it&#39;s job. 

         Also, I think the request queue is indicated by the output dpcd1 near the very
         end of the line. 
    
         Now below we have entered the function that is pasted above. In the function
         you can see that the slot can be determined by the queue. And the log output
         after the stack dump shows it is from slot 1. (The first network drive that was
         already mounted.) */
      
            kernel: [231644.155677]  ndas-44700486-0:Pid: 467, comm: nd/dpcd1 Tainted: P           2.6.32-5-686 #1
      kernel: [231644.155711] Call Trace:
      kernel: [231644.155723]  [&lt;fc5a7685&gt;] ? nblk_request_proc+0x9/0x10c [ndas_block]
      kernel: [231644.155732]  [&lt;c11298db&gt;] ? __generic_unplug_device+0x23/0x25
      kernel: [231644.155737]  [&lt;c1129afb&gt;] ? generic_unplug_device+0x1e/0x2e
      kernel: [231644.155743]  [&lt;c1123090&gt;] ? blk_unplug+0x2e/0x31
      kernel: [231644.155750]  [&lt;c10cceec&gt;] ? block_sync_page+0x33/0x34
      kernel: [231644.155756]  [&lt;c108770c&gt;] ? sync_page+0x35/0x3d
      kernel: [231644.155763]  [&lt;c126d568&gt;] ? __wait_on_bit_lock+0x31/0x6a
      kernel: [231644.155768]  [&lt;c10876d7&gt;] ? sync_page+0x0/0x3d
      kernel: [231644.155773]  [&lt;c10876aa&gt;] ? __lock_page+0x76/0x7e
      kernel: [231644.155780]  [&lt;c1043f1f&gt;] ? wake_bit_function+0x0/0x3c
      kernel: [231644.155785]  [&lt;c1087b76&gt;] ? do_read_cache_page+0xdf/0xf8
      kernel: [231644.155791]  [&lt;c10d21b9&gt;] ? blkdev_readpage+0x0/0xc
      kernel: [231644.155796]  [&lt;c1087bbc&gt;] ? read_cache_page_async+0x14/0x18
      kernel: [231644.155801]  [&lt;c1087bc9&gt;] ? read_cache_page+0x9/0xf
      kernel: [231644.155808]  [&lt;c10ed6fc&gt;] ? read_dev_sector+0x26/0x60
      kernel: [231644.155813]  [&lt;c10ee368&gt;] ? adfspart_check_ICS+0x20/0x14c
      kernel: [231644.155819]  [&lt;c10ee138&gt;] ? rescan_partitions+0x17e/0x378
      kernel: [231644.155825]  [&lt;c10ee348&gt;] ? adfspart_check_ICS+0x0/0x14c
      kernel: [231644.155830]  [&lt;c10d26a3&gt;] ? __blkdev_get+0x225/0x2c7
      kernel: [231644.155836]  [&lt;c10ed7e6&gt;] ? register_disk+0xb0/0xfd
      kernel: [231644.155843]  [&lt;c112e33b&gt;] ? add_disk+0x9a/0xe8
      kernel: [231644.155848]  [&lt;c112dafd&gt;] ? exact_match+0x0/0x4
      kernel: [231644.155853]  [&lt;c112deae&gt;] ? exact_lock+0x0/0xd
      kernel: [231644.155861]  [&lt;fc5a8b80&gt;] ? slot_enable+0x405/0x4a5 [ndas_block]
      kernel: [231644.155868]  [&lt;fc5a8c63&gt;] ? ndcmd_enabled_handler+0x43/0x9e [ndas_block]
      kernel: [231644.155874]  [&lt;fc5a8c20&gt;] ? ndcmd_enabled_handler+0x0/0x9e [ndas_block]
      kernel: [231644.155891]  [&lt;fc54b22b&gt;] ? notify_func+0x38/0x4b [ndas_core]
      kernel: [231644.155906]  [&lt;fc561cba&gt;] ? _dpc_cancel+0x17c/0x626 [ndas_core]
      kernel: [231644.155919]  [&lt;fc562005&gt;] ? _dpc_cancel+0x4c7/0x626 [ndas_core]
      kernel: [231644.155933]  [&lt;fc561cba&gt;] ? _dpc_cancel+0x17c/0x626 [ndas_core]
      kernel: [231644.155941]  [&lt;c1003d47&gt;] ? kernel_thread_helper+0x7/0x10
      
      /* here are the output of the driver debugs. They show that this operation is
         being performed on the first devices request queue. */

      kernel: [231644.155948] BL|8|nblk_request_proc|/driver/block/block26.c:494|processing queue request from slot 1|nd/dpcd1,64:15:44.38,3408:10
      kernel: [231644.155959] BL|8|nblk_handle_io|/driver/block/block26.c:374|struct ndas_slot sd = NDAS GET SLOT DEV(slot 1)
      kernel: [231644.155966] |nd/dpcd1,64:15:44.38,3328:10
      kernel: [231644.155970] BL|8|nblk_handle_io|/driver/block/block26.c:458|case READA call ndas_read(slot=1, ndas_req)|nd/dpcd1,64:15:44.38,3328:10
      kernel: [231644.155979] ND|8|ndas_read|netdisk/nddev.c:824|read io: slot=1, cmd=0, req=x00|nd/dpcd1,64:15:44.38,3320:10
      

I hope this is enough background information. Maybe an obvious question at this moment is &quot;When and where are the request_queues assigned?&quot; 

Well that is handled a little bit before the add_disk function. adding disk, is the first line on the log output. 

    slot-&gt;disk = NULL;
    spin_lock_init(&amp;slot-&gt;lock);
    slot-&gt;queue = blk_init_queue(
        nblk_request_proc, 
        &amp;slot-&gt;lock
    );

As far as I know, this is the standard operation. So back to my original question. Can I find the request queue somewhere and make sure it is incremented or unique for each new device or does the Linux kernel only use one queue for each Major number? I want to discover why this driver is loading the same queue on two different block storages, and determine if that is causing the duplicate blkid during the initial registration process.

Thanks for looking at this situation for me. 

How can I identify the request queue for a linux block device

I am sorry to ask this question when it has already been asked but I couldn&#39;t get a clarity from them. So I am asking the following related questions to get the difference between system call (mode-switch) and context switch 

- Why is it said that the system call doesn&#39;t require context switch when the context of the 
process making the call has to be saved and then reloaded. Is it just because according to the definition of context switch a switch has to be made to another process.

- What does it mean that when a system call is made the kernel executes in &quot;user context&quot;.


- According to the wikipedia article : [http://en.wikipedia.org/wiki/Context_switch][1]

a context switch is not necessary for system call but it depends on the operating system and a context switch might occur during a system call. I am wondering what would happen in the case when the context switch takes place at the time of system call. Any examples?


  [1]: http://en.wikipedia.org/wiki/Context_switch

System call and context switch

I&#39;m trying to understand the use of `dup2` and `dup`. 

From the man page : 

    DESCRIPTION
    
    dup and dup2 create a copy of the file descriptor oldfd.
    After successful return of dup or dup2, the old and new descriptors may
    be used interchangeably. They share locks, file position pointers and
    flags; for example, if the file position is modified by using lseek on
    one of the descriptors, the position is also changed for the other.
    
    The two descriptors do not share the close-on-exec flag, however.
    
    dup uses the lowest-numbered unused descriptor for the new descriptor.
    
    dup2 makes newfd be the copy of oldfd, closing newfd first if necessary.  
    
    RETURN VALUE
    
    dup and dup2 return the new descriptor, or -1 if an error occurred 
    (in which case, errno is set appropriately).  

Why would I need that system call? what is the use of duplicating the file descriptor? 

If I have the file descriptor, why would I want to make a copy of it? 

I&#39;d appreciate if you could explain and give me an example where `dup2` / `dup` is needed. 

Thanks

dup2 / dup - why would I need to duplicate a file descriptor?

I study the Linux kernel and found out that for x86_64 architecture the interrupt `int 0x80` doesn&#39;t work for calling system calls&lt;sup&gt;1&lt;/sup&gt;.

**For the i386 architecture (32-bit x86 user-space), what is more preferable: `syscall` or `int 0x80` and why?**

I use Linux kernel version 3.4.

---

Footnote 1: `int 0x80` does work in some cases in 64-bit code, but is never recommended.  https://stackoverflow.com/questions/46087730/what-happens-if-you-use-the-32-bit-int-0x80-linux-abi-in-64-bit-code



What is better &quot;int 0x80&quot; or &quot;syscall&quot; in 32-bit code on Linux?

`int 0x80` on Linux always invokes the 32-bit ABI, regardless of what mode it&#39;s called from:  args in `ebx`, `ecx`, ... and syscall numbers from `/usr/include/asm/unistd_32.h`.   (Or crashes on 64-bit kernels compiled without `CONFIG_IA32_EMULATION`).

**64-bit code should use `syscall`**, with call numbers from `/usr/include/asm/unistd_64.h`, and args in `rdi`, `rsi`, etc.  See https://stackoverflow.com/questions/2535989/what-are-the-calling-conventions-for-unix-linux-system-calls-on-x86-64.  If your question was marked a duplicate of this, **see that link for details on how you *should* make system calls in 32 or 64-bit code.**  If you want to understand what exactly happened, keep reading.

(For an example of 32-bit vs. 64-bit `sys_write`, see https://stackoverflow.com/questions/22503944/using-interrupt-0x80-on-64-bit-linux)

---

`syscall` system calls are faster than `int 0x80` system calls, so use native 64-bit `syscall` unless you&#39;re writing polyglot machine code that runs the same when executed as 32 or 64 bit.  (`sysenter` always returns in 32-bit mode, so it&#39;s not useful from 64-bit userspace, although it is a valid x86-64 instruction.)

Related: [**The Definitive Guide to Linux System Calls** (on x86)][1] for how to make `int 0x80` or `sysenter` 32-bit system calls, or `syscall` 64-bit system calls, or calling the vDSO for &quot;virtual&quot; system calls like `gettimeofday`.  Plus background on what system calls are all about.

---

Using `int 0x80` makes it possible to write something that will assemble in 32 or 64-bit mode, so it&#39;s handy for an `exit_group()` at the end of a microbenchmark or something.

Current PDFs of the official i386 and x86-64 System V psABI documents that standardize function and syscall calling conventions are linked from https://github.com/hjl-tools/x86-psABI/wiki/X86-psABI.

See the [tag:x86] tag [wiki][2] for beginner guides, x86 manuals, official documentation, and performance optimization guides / resources.

----

But since people keep posting questions with code that uses [`int 0x80` in 64-bit code][3], or accidentally [building 64-bit binaries][4] from source written for 32-bit, I wonder **what *exactly* does happen on current Linux?**

**Does `int 0x80` save/restore all the 64-bit registers?  Does it truncate any registers to 32-bit?  What happens if you pass pointer args that have non-zero upper halves?**

**Does it work if you pass it 32-bit pointers?**


  [1]: https://blog.packagecloud.io/eng/2016/04/05/the-definitive-guide-to-linux-system-calls/
  [2]: https://stackoverflow.com/tags/x86/info
  [3]: https://stackoverflow.com/questions/14033028/sys-read-syscall-vs-int-0x80-in-gnu-assembler
  [4]: https://stackoverflow.com/questions/36861903/assembling-32-bit-binaries-on-a-64-bit-system-gnu-toolchain

Content Type	Original Author	Original Content on Stackoverflow
Question	Wei Hu	View Question on Stackoverflow
Solution 1 - Linux	araqnid	View Answer on Stackoverflow
Solution 2 - Linux	Ritwik Dey	View Answer on Stackoverflow

Magic numbers of the Linux reboot() system call

Linux Problem Overview

Linux Solutions

Solution 1 - Linux

Solution 2 - Linux

Convert NSString to NSInteger?

subprocess.check_output() doesn't seem to exist (Python 2.6.5)

Attributions