The [man page](https://www.man7.org/linux/man-pages/man1/top.1.html) says what the state codes are mapped to, but not what they actually mean. From the `top` man page:

    &#39;D&#39; = uninterruptible sleep
    &#39;R&#39; = running
    &#39;S&#39; = sleeping
    &#39;T&#39; = traced or stopped
    &#39;Z&#39; = zombie

&#39;R&#39; is the easiest; the process is ready to run, and will run whenever its turn to use the CPU comes.

&#39;S&#39; and &#39;D&#39; are two sleep states, where the process is waiting for something to happen. The difference is that &#39;S&#39; can be interrupted by a signal, while &#39;D&#39; cannot (it is usually seen when the process is waiting for the disk).

&#39;T&#39; is a state where the process is stopped, usually via `SIGSTOP` or `SIGTSTP`. It can also be stopped by a debugger (`ptrace`). When you see that state, it usually is because you used &lt;kbd&gt;Ctrl&lt;/kbd&gt;+ &lt;kbd&gt;Z&lt;/kbd&gt; to put a command on the background.

&#39;Z&#39; is a state where the process is dead (it has finished its execution), and the only thing left is the structure describing it on the kernel. It is waiting for its parent process to retrieve its exit code, and not much more. After its parent process is finished with it, it will disappear.


You can use the command [`man top`](https://www.man7.org/linux/man-pages/man1/top.1.html) to look up the states:


    D = uninterruptible sleep
    I = idle
    R = running
    S = sleeping
    T = stopped by job control signal
    t = stopped by debugger during trace
    Z = zombie


Programs like `top` and `ps` takes these values from the kernel itself. You can find its definitions in the source code here:

https://github.com/torvalds/linux/blob/3950e975431bc914f7e81b8f2a2dbdf2064acb0f/fs/proc/array.c#L129-L143

```c
static const char * const task_state_array[] = {

	/* states in TASK_REPORT: */
	&quot;R (running)&quot;,		/* 0x00 */
	&quot;S (sleeping)&quot;,		/* 0x01 */
	&quot;D (disk sleep)&quot;,	/* 0x02 */
	&quot;T (stopped)&quot;,		/* 0x04 */
	&quot;t (tracing stop)&quot;,	/* 0x08 */
	&quot;X (dead)&quot;,		/* 0x10 */
	&quot;Z (zombie)&quot;,		/* 0x20 */
	&quot;P (parked)&quot;,		/* 0x40 */

	/* states beyond TASK_REPORT: */
	&quot;I (idle)&quot;,		/* 0x80 */
};
```

For more info see this question: https://unix.stackexchange.com/q/462098/79648

I&#39;m currently using `std::ofstream` as follows:

	std::ofstream outFile;
	outFile.open(output_file);

Then I attempt to pass a `std::stringstream` object to `outFile` as follows:

    GetHolesResults(..., std::ofstream &amp;outFile){
      float x = 1234;
      std::stringstream ss;
      ss &lt;&lt; x &lt;&lt; std::endl;
      outFile &lt;&lt; ss;
    }

Now my `outFile` contains nothing but garbage: &quot;0012E708&quot; repeated all over.

In `GetHolesResults` I can write 

    outFile &lt;&lt; &quot;Foo&quot; &lt;&lt; std:endl; 

and it will output correctly in `outFile`.

Any suggestion on what I&#39;m doing wrong?

Writing stringstream contents into ofstream

I am trying to improve the performance of the threaded application with real-time deadlines. It is running on Windows Mobile and written in C / C++. I have a suspicion that high frequency of thread switching might be causing tangible overhead, but can neither prove it or disprove it. As everybody knows, lack of proof is not a proof of opposite :).

Thus my question is twofold:
 
 - If exists at all, where can I find any actual measurements of the cost of switching thread context?

 - Without spending time writing a test application, what are the ways to estimate the thread switching overhead in the existing application?

 - Does anyone know a way to find out the number of context switches (on / off) for a given thread?

How to estimate the thread context switching overhead?

When you run `top` and see all running processes, I&#39;ve always wanted to know just what everything actually means.  e.g. all the various single-letter state codes for a running process (R = Running, S = Sleeping, etc...)

Where can I find this?


In Linux, what do all the values in the &quot;top&quot; command mean?

<p>When you run <code>top</code> and see all running processes, I've always wanted to know just what everything actually means.  e.g. all the various single-letter state codes for a running process (R = Running, S = Sleeping, etc...)</p>
<p>Where can I find this?</p>


I am looking for a tool like [ltrace][1] or [strace][2] that can trace locally defined functions in an executable.  ltrace only traces dynamic library calls and strace only traces system calls.  For example, given the following C program:

    #include &lt;stdio.h&gt;
    
    int triple ( int x )
    {
      return 3 * x;
    }
    
    int main (void)
    {
      printf(&quot;%d\n&quot;, triple(10));
      return 0;
    }

Running the program with `ltrace` will show the call to `printf` since that is a standard library function (which is a dynamic library on my system) and `strace` will show all the system calls from the startup code, the system calls used to implement printf, and the shutdown code, but I want something that will show me that the function `triple` was called.  Assuming that the local functions have not been inlined by an optimizing compiler and that the binary has not been stripped (symbols removed), is there a tool that can do this?

**Edit**

A couple of clarifications:

  - It is okay if the tool also provides trace information for non-local functions.
  - I don&#39;t want to have to recompile the program(s) with support for specific tools, the symbol information in the executable should be enough.
  - I would be really nice if I could use the tool to attach to existing processes like I can with ltrace/strace.

  [1]: http://linux.die.net/man/1/ltrace
  [2]: http://linux.die.net/man/1/strace

Tool to trace local function calls in Linux

Suppose I want to count the lines of code in a project. If all of the files are in the same directory I can execute:

    cat * | wc -l

However, if there are sub-directories, this doesn&#39;t work. For this to work cat would have to have a recursive mode. I suspect this might be a job for xargs, but I wonder if there is a more elegant solution?

How to count lines of code including sub-directories

I need to edit `/etc/sudoers` from a script to add/remove stuff from white lists.

Assuming I have a command that would work on a normal file, how could I apply it to `/etc/sudoers`?

Can I copy and modify it, then have `visudo` replace the original with the modified copy? By providing my own script in `$EDITOR`?

Or can I just use the same locks and `cp`?

The question is more about potential issues than about just finding something that works.


How do I edit /etc/sudoers from a script?

I am attempting to link an application with g++ on this Debian lenny system. ld is complaining it cannot find specified libraries. The specific example here is ImageMagick, but I am having similar problems with a few other libraries too.

I am calling the linker with:

    g++ -w (..lots of .o files/include directories/etc..) \
    -L/usr/lib -lmagic

ld complains:

    /usr/bin/ld: cannot find -lmagic

However, libmagic exists:

	$ locate libmagic.so
	/usr/lib/libmagic.so.1
	/usr/lib/libmagic.so.1.0.0
	$ ls -all /usr/lib/libmagic.so.1*
	lrwxrwxrwx 1 root root    17 2008-12-01 03:52 /usr/lib/libmagic.so.1 -&gt; libmagic.so.1.0.0
	-rwxrwxrwx 1 root root 84664 2008-09-09 00:05 /usr/lib/libmagic.so.1.0.0
	$ ldd /usr/lib/libmagic.so.1.0.0 
		linux-gate.so.1 =&gt;  (0xb7f85000)
		libz.so.1 =&gt; /usr/lib/libz.so.1 (0xb7f51000)
		libc.so.6 =&gt; /lib/i686/cmov/libc.so.6 (0xb7df6000)
		/lib/ld-linux.so.2 (0xb7f86000)
	$ sudo ldconfig -v | grep &quot;libmagic&quot;
		libmagic.so.1 -&gt; libmagic.so.1.0.0

How do I diagnose this problem further, and what could be wrong? Am I doing something completely stupid?


ld cannot find an existing library

What is the maximum number of threads that can be created by a process under Linux?

How (if possible) can this value be modified?

Maximum number of threads per process in Linux?

I am running a program and want to see what its return code is (since it returns different codes based on different errors).

I know in Bash I can do this by running

&gt; echo $?

What do I do when using cmd.exe on Windows?

How do I get the application exit code from a Windows command line?

I&#39;m trying to prevent `bash` from saving duplicate commands to my history. Here&#39;s what I&#39;ve got:

    shopt -s histappend
    export HISTIGNORE=&#39;&amp;:ls:cd ~:cd ..:[bf]g:exit:h:history&#39;
    export HISTCONTROL=erasedups
    export PROMPT_COMMAND=&#39;history -a&#39;

This works fine while I&#39;m logged in and `.bash_history` is in memory. For example:

    $ history
        1 vi .bashrc
        2 vi .alias
        3 cd /cygdrive
        4 cd ~jplemme
        5 vi .bashrc
        6 vi .alias
    
    $ vi .bashrc
    
    $ history
        1 vi .alias
        2 cd /cygdrive
        3 cd ~jplemme
        4 vi .alias
        5 vi .bashrc
    
    $ vi .alias
    
    $ history
        1 cd /cygdrive
        2 cd ~jplemme
        3 vi .bashrc
        4 vi .alias
    
    $ exit

But when I log back in, my history file looks like this:

    $ history
        1 vi .bashrc
        2 vi .alias
        3 cd /cygdrive
        4 cd ~jplemme
        5 vi .bashrc
        6 vi .alias
        7 vi .bashrc
        8 vi .alias

What am I doing wrong?

EDIT: Removing the `shopt` and `PROMPT_COMMAND` lines from `.bashrc` does not fix the problem.

Prevent duplicates from being saved in bash history

In Unix/Linux, how do you find out what group a given user is in via command line?

How to find out what group a given user has?

I have a utility (grep) that gives me a list of filenames and a line numbers. After I have determined that devenv is the correct program to open a file, I would like to ensure that it is opened at the indicated line number. In emacs, this would be:

    emacs +140 filename.c

I have found nothing like this for Visual Studio (devenv). The closest I have found is:

    devenv /Command &quot;Edit.Goto 140&quot; filename.c

However, this makes a separate instance of devenv for each such file. I would rather have something that uses an existing instance.

These variations re-use an existing devenv, but don&#39;t go to the indicated line:

    devenv /Command &quot;Edit.Goto 140&quot; /Edit filename.c
    devenv /Command  /Edit filename.c &quot;Edit.Goto 140&quot;

I thought that using multiple &quot;/Command&quot; arguments might do it, but I probably don&#39;t have the right one because I either get errors or no response at all (other than opening an empty devenv).

I could write a special macro for devenv, but I would like this utility to be used by others that don&#39;t have that macro. And I&#39;m not clear on how to invoke that macro with the &quot;/Command&quot; option.

Any ideas?


----------


Well, it doesn&#39;t appear that there is a way to do this as I wanted. Since it looks like I&#39;ll need to have dedicated code to start up Visual Studio, I&#39;ve decided to use EnvDTE as shown below. Hopefully this will help somebody else.

&lt;!-- language: lang-cpp --&gt; 

    #include &quot;stdafx.h&quot;
    
    //-----------------------------------------------------------------------
    // This code is blatently stolen from http://benbuck.com/archives/13
    //
    // This is from the blog of somebody called &quot;BenBuck&quot; for which there
    // seems to be no information.
    //-----------------------------------------------------------------------
    
    // import EnvDTE
    #pragma warning(disable : 4278)
    #pragma warning(disable : 4146)
    #import &quot;libid:80cc9f66-e7d8-4ddd-85b6-d9e6cd0e93e2&quot; version(&quot;8.0&quot;) lcid(&quot;0&quot;) raw_interfaces_only named_guids
    #pragma warning(default : 4146)
    #pragma warning(default : 4278)
    
    bool visual_studio_open_file(char const *filename, unsigned int line)
    {
    	HRESULT result;
    	CLSID clsid;
    	result = ::CLSIDFromProgID(L&quot;VisualStudio.DTE&quot;, &amp;clsid);
    	if (FAILED(result))
    		return false;
    
    	CComPtr&lt;IUnknown&gt; punk;
    	result = ::GetActiveObject(clsid, NULL, &amp;punk);
    	if (FAILED(result))
    		return false;
    
    	CComPtr&lt;EnvDTE::_DTE&gt; DTE;
    	DTE = punk;
    
    	CComPtr&lt;EnvDTE::ItemOperations&gt; item_ops;
    	result = DTE-&gt;get_ItemOperations(&amp;item_ops);
    	if (FAILED(result))
    		return false;
    
    	CComBSTR bstrFileName(filename);
    	CComBSTR bstrKind(EnvDTE::vsViewKindTextView);
    	CComPtr&lt;EnvDTE::Window&gt; window;
    	result = item_ops-&gt;OpenFile(bstrFileName, bstrKind, &amp;window);
    	if (FAILED(result))
    		return false;
    
    	CComPtr&lt;EnvDTE::Document&gt; doc;
    	result = DTE-&gt;get_ActiveDocument(&amp;doc);
    	if (FAILED(result))
    		return false;
    
    	CComPtr&lt;IDispatch&gt; selection_dispatch;
    	result = doc-&gt;get_Selection(&amp;selection_dispatch);
    	if (FAILED(result))
    		return false;
    
    	CComPtr&lt;EnvDTE::TextSelection&gt; selection;
    	result = selection_dispatch-&gt;QueryInterface(&amp;selection);
    	if (FAILED(result))
    		return false;
    
    	result = selection-&gt;GotoLine(line, TRUE);
    	if (FAILED(result))
    		return false;
    
    	return true;
    }



Open a file in Visual Studio at a specific line number

Is there a (Unix) shell script to format JSON in human-readable form?

Basically, I want it to transform the following:

```json
{ &quot;foo&quot;: &quot;lorem&quot;, &quot;bar&quot;: &quot;ipsum&quot; }
```

... into something like this:

```json
{
    &quot;foo&quot;: &quot;lorem&quot;,
    &quot;bar&quot;: &quot;ipsum&quot;
}
```

How can I pretty-print JSON in a shell script?

Is there a htop/top on Linux where I get to sort processes by network usage?

Network usage top/htop on Linux

If you call the top command, you get all the running processes. But how can I *limit* the output only *to a certain process name like &quot;java&quot;*?

I&#39;ve tried this 
 **top -l 2 | grep java**
but in this way you get only snapshots and not a continuously updated list. And **top -l 0 | grep java** is not really clear.

Limit the output of the TOP command to a specific process name

    top -c

Top lists all the processes, there are good options to filter the processes by username by using the option -u &lt;username&gt; but I am wondering if there is any easy way to filter the processes based on processname listed under COMMAND column of the top output.

For Example I would want like top -some option -substring of processname and top displays pids only having this substring in its command name


Content Type	Original Author	Original Content on Stackoverflow
Question	Aaron Fi	View Question on Stackoverflow
Solution 1 - Linux	CesarB	View Answer on Stackoverflow
Solution 2 - Linux	SMB	View Answer on Stackoverflow
Solution 3 - Linux	congusbongus	View Answer on Stackoverflow

In Linux, what do all the values in the "top" command mean?

Linux Problem Overview

Linux Solutions

Solution 1 - Linux

Solution 2 - Linux

Solution 3 - Linux

How to estimate the thread context switching overhead?

Writing stringstream contents into ofstream

Attributions