Does anyone know how to determine a user process through a single command in Solaris and Linux ? (Iam not speaking about ps command)

Here is the command

# pgrep -l -u <username>

eg: # pgrep -l -u test

This will display the PIDs and Process names

Eureka..

After this you can kill the process with its id

# kill <PID value>

1) ps = report process status

ps : typing ps alone would list the current running processes

ps -u username : to search processes run by a certain user

ps ag : to get information about all running process

ps aux : to display the owner of the processes along with the processes

ps ax | grep  processname : to see if a particular process is running or not

.

2) ptree : to display a tree of processeses

pstree -p | less : also display the pid of the process

.

3) pgrep : look up or signal processes based on name and other attributes

pgrep sshd : to list the processes called sshd

pgrep -u root sshd : will only list the processes called sshd AND owned by root

pgrep -u root,daemon : will list the processes owned by root OR daemon

.

4) pidof – find the process ID of a running program

pidof emacs – list the process id for emacs

pgrep and pidof is much the same except that grep is more powerful it has more options (check man pages for both)

.

5) pkill = kill all processes matching the search text

pkill sshd : kill all sshd processes

pkill -9 –u userlogin : kill a process owned by a particular user

.

6) kill = Send a signal to terminate one or more process IDs

kill 2345 : terminate process 2345 (to list process id use ps)

kill -9 2345 : if kill 2345 doesnt work, use kill -9 2345 to force it

.

7) killall = kill all processes by name

killall nautilus

Unlike the kill command, it is not necessary to first try to find the PID(s) for nautilus. And if there are multiple instances of nautilus running, all will be terminated immediately.

killall is similar to pkill

De atoztoa en ATOzTOA

Encontrar rápidamente el PID con pgrep

pgrep busca en los procesos ejecutados actualmente enumerando los identificadores de procesos que coincide con el criterio de búsqueda.

pgrep ssh
-Da como resultado todos los PID asociados con el proceso ssh.

Ejecutar el último comando

!!
Ejecuta el último comando que has usado en la línea de comandos.

¿No se usa la tecla flecha arriba para eso?

El comando !! es muy útil cuando te olvidas de empezar un comando con sudo:

apt-get update
sudo !!

Ejecutar el último comando que empieza con…

Si quieres ejecutar el último comando del historial que empieza por S puedes usar el siguiente comando:

!s
-Ejecuta el último comando del historial que empiece con s.

Último argumento

Puedes usar el último argumento del comando anterior con $_

por lo que sólo tendrás que escribir una ruta larga una vez:
cp assignment.htm /home/phill/reports/2008/
cd $_
para ir directamente a la carpeta

Puedes usarlo como te guste. Pero siempre el último argumento del comando anterior.

Al igual que con $_ para obtener el último argumento, puedes pulsar ALT+ para pegar de forma instantánea en la posición del cursor.

Ejecutar un comando repetidamente y mostrar su salida

watch ejecuta un comando periódicamente, mostrando su salida. Te permite monitorizar la salida del programa cada cierto tiempo. Por defecto, el programa se ejecuta cada dos segundos. Watch es muy similar a tail.

watch -d ls -l
-Monitoriza el directorio actual en busca de cambios y los resalta si el cambio ocurre.

Guardar archivos rápidamente en VI/VIM

Puedes usar :wp y más fácil aun

Salir inmediatamente del terminal

Para salir rápidamente de la sesión del terminal basta con presionar CTRL+D

Ir al último directorio donde estabas

cd -
te lleva al último directorio donde estabas

Crear directorios padres de forma inteligente

mkdir -p /home/adam/make/all/of/these/directories/ crea todos los directorios, incluso si no existen. No necesitas hacer mkdir make ; cd make ; mkdir all ; cd all ; mkdir of ; cd of …

Borrar una línea completa

Si has escrito una larga línea que no necesitas ejecutar, borra la línea con: CTRL+U,K. Eso no es fácil. CTRL+U borra todo lo que este a la izquierda del cursor y CTRL+K lo de la derecha. Como alternativa, se puede usar CTRL+C que descarta el actual comando escrito, y da una nueva línea. CTRL+L limpia la pantalla.

Establecer la fecha y hora de un archivo

touch -c -t 0801010800 filename.c pone la fecha y hora del archivo a 2008-01-01 a 8:00. El formato es (YYMMDDhhmm)

Editar un comando

fc abre el último comando de tu historial shell en el editor por defecto. Se puede especificar un editor. Le puedes indicar el número de línea del historial del comando o las primeras letras del comando más reciente.
fc -e kate wget
- abre kate con el último comando del historial que empieza por wget. Cuando lo edites, guardes y cierres kate, el comando será ejecutado.

Signo &

Al terminar un comando con el signo & se ejecuta el comando con un nuevo PID, dejando libre la línea de comandos. Útil para correr comandos en segundo plano.

Reiniciar su sesión de comandos

En lugar de matar y volver a comenzar su sesión de terminal, simplemente escribe el comando reset. Se restablecerá el terminal a su valor por defecto, borra la pantalla, y todo será como lo era antes.

In Solaris 9, two new utilities were added: pkill and pgrep. These tools are perhaps old news to Solaris admins. However, these utilities were then quietly added to Linux in short order, and now show up in HP-UX 11i v3 and perhaps others. What do these tools do?

First of all, pkill is just a wrapper for pgrep. Well, what does pgrep do? It searches the current processes for a match based on arguments that you give to it.

The most common use would be to search for a command. The pgrep utility will then return each process ID, one per line. The pkill utility will send the default kill signal to each pid. The pgrep utility can search based on a large array of factors, including userid, groupid, virtual size, effective user ids, command name, full command string, and more.

Here’s an example:

# pgrep cache
13
12
14
15
33
49
22006
21950
21973
21976
#

When combined with scripting, these commands can be quite useful. Consider this ksh snippet:

for i in $(pgrep cache) ; do
  // do some commands here
done

A couple of days ago I was needing to solve an issue with our EAI framework. The implementation of such framework could be basically described as instances of Java programs running under Solaris, but there’s a particular instance that should be running just once. So I wrote this tiny shell script to avoid launching that program twice:

#!/bin/ksh
#
theProcess=someProcess
if [ $(pgrep -u $USER -f $theProcess | wc -l) -gt 0 ] then
echo "There is an instance of "$theProcess" already running."
else runTheProcess
fi

someProcess could be any regex that matches the process description,
runTheProcess is whatever command that executes the process.
Okay, that’s all, I hope you’ve found it informative and thanks for reading!

Yes, this is my first attempt of creating a list of useful, everyday bash commands – as I find myself constantly in the situation looking for a specific bash command. If you’re unlucky, googleing the right command (especially if you don’t know what it’s called) can cost you several minutes if not hours.

So this will save me and hopefully you as well, the next time plenty of time. If you think there’s an important command still missing, which is more than likely, feel free to leave a comment with the command and a short explanation what it does.

Very special thanks to Bernd for the idea and his input! Thank you!

Basics:

cp test.txt /home/user/Desktop copies a txt file called test to the user’s Desktop

mv /home/test.txt /home/user/Desktop/ moves a txt file called test from the user’s home directory to the Desktop

sudo chmod -R 755 * changes the user rights recursively for the owner to read, write and execute – for group and world to read and execute. (this command requires root rights «sudo»)

sudo chmod -R u+w /home/user/data changes the user rights for the owner recursively to write and read of the directory /home/user/data

echo $USER prints the currently being used user name

sudo chown -R $USER.users ~/.kde/share/apps/kmail/mail changes the user ownership of the directory ~/.kde/share/apps/kmail/mail to the currently being used user name

ls -la ~/.kde/share/apps/ lists the content of a directory e.g ~/kde/share/apps/

ls | wc -l counts the files in a directory

cp test.txt{.bkp} copies text.txt to text.txt.bkp (creates a backup)

uname -a or uname -a | awk '{print $3}' lists your current kernel version number (awk ‘{print $3} prints only the kernel version, without its description)

Going deep:

perl -pi.bak -e 's/search/replace/' *.php replaces in all .php files the word “search” with “replace” and creates a backup file .bak e.g. index.php to index.php.bak

grep --color ; displays the search result in colour

grep -r searches /home/ searches recursively in /home/

pgrep firefox displays the process ID number of firefox or any application. useful to «kill» a process

sudo kill -9 pid pid = processID number ….. kill -9 kills the process (requires root rights)

sudo /etc/init.d/networking restart restarts the networking service

Mounting:

sudo mkdir hda1 creates a directory called “hda1″

sudo mount /dev/hda1 /mnt/hda1 mounts the harddisk hda1 into the directory /mnt/hda1

sudo umount /dev/sdb5 unmounts a device «sdb5» (in this case usb device)

sudo mount -t ntfs-3g /dev/hda5 /mnt/windows -o locale=de_DE.utf8 mounts a NTFS formatted harddisk read and writeable into /mnt/windows (this implies that the packages «ntfs-3g» & «ntfs-config» are installed)

sudo mount -t vfat /dev/hda1 /mnt/windows_c mounts a FAT formatted harddisk read and writeable into /mnt/windows_c

sudo blkid shows UUID number of a device

mount lists mounted devices

lsusb lists usb devices

sudo fdisk -l lists all mounted and unmounted harddisks or partitions

fuser -v /mount/point displays why a device can’t be unmounted and which process/user uses the device

Misc:

update-alternatives --config editor let’s you change the standard terminal editor (e.g from vim to nano)

ls -la /etc/alternatives/javac lists all java compilers

java -version displays the currently installed java version

msgfmt test.po -o test.mo compiles a language translation file (po) into a binary .mo file …. -o stands for output

sudo aptitude install language-pack-gnome-de installs a package from a repository (e.g. german gnome language pack)

sudo aptitude install tree installs a package called «tree»

tree -d -i (-i removes the 'tree') lists directories and subdirectories…
tree -d -i > dir.txt lists directories and subdirectories and saves the content into dir.txt

aptitude show ktorrent shows information on ktorrent and lists where it’s available (which repository)

MPLAYER:
mplayer -dumpstream "mms://a1505.v16544e.c16544.g.vm.akamaistream.net/7/1505/16544/v001/roomediaco1.download.akamai.com/16544/wm.roomedia/streamingVX/17056/1386/laptop_300.wmv?clipId=1386_computing_0030&channel=Netevents+TV&category=netevents+tv&site=vnudotnet%2fcomputing" -dumpfile laptop.wmv downloads a stream and saves it as «laptop.wmv»

Most administrators (and UNIX users) will probably know about the kill command – and will know not to use kill -9 without first trying the kill command by itself. You may also be aware that kill (by itself) sends a SIGTERM signal to the process, and that signal 9 is the SIGKILL signal.

There are many other signals; they are usually available with the kill -l command. OpenBSD returns this output:

# kill -l
1 HUP Hangup 17 STOP Suspended (signal)
2 INT Interrupt 18 TSTP Suspended
3 QUIT Quit 19 CONT Continued
4 ILL Illegal instruction 20 CHLD Child exited
5 TRAP Trace/BPT trap 21 TTIN Stopped (tty input)
6 ABRT Abort trap 22 TTOU Stopped (tty output)
7 EMT EMT trap 23 IO I/O possible
8 FPE Floating point exception 24 XCPU Cputime limit exceeded
9 KILL Killed 25 XFSZ Filesize limit exceeded
10 BUS Bus error 26 VTALRM Virtual timer expired
11 SEGV Segmentation fault 27 PROF Profiling timer expired
12 SYS Bad system call 28 WINCH Window size changes
13 PIPE Broken pipe 29 INFO Information request
14 ALRM Alarm clock 30 USR1 User defined signal 1
15 TERM Terminated 31 USR2 User defined signal 2
16 URG Urgent I/O condition
#

However, the output is not always so helpful, though it always reports on the available signals. HP-UX reports thusly:

# kill -l
1) HUP
2) INT
3) QUIT
4) ILL
5) TRAP
6) ABRT
7) EMT
FPE
9) KILL
10) BUS
11) SEGV
12) SYS
13) PIPE
14) ALRM
15) TERM
16) USR1
17) USR2
18) CHLD
19) PWR
20) VTALRM
21) PROF
22) IO
23) WINCH
24) STOP
25) TSTP
26) CONT
27) TTIN
28) TTOU
29) URG
30) LOST
31) RESERVED
32) The specified trap syntax is not correct.
33) XCPU
34) XFSZ
35) The specified trap syntax is not correct.
36) The specified trap syntax is not correct.
37) RTMIN
38) RTMIN+1
39) RTMIN+2
40) RTMIN+3
41) RTMAX-3
42) RTMAX-2
43) RTMAX-1
44) RTMAX

You may also note that higher numbered signals tend to vary more.

There are several signals to note. One not commonly used is SIGCHLD: when you have a zombie process, note the parent of the zombie process and send it a SIGCHLD signal: kill -CHLD ppid . This will, in a proper situation, cause that program to reap its children and cause the zombie to disappear. Whether it actually works or not – you just have to try it.

Another signal not often used is the STOP signal. If there is a unimportant process hogging the processing power of the machine, it can be “stopped” (that is, frozen) and left in its place: kill -STOP pid . Then later, the process can be continued with the command: kill -CONT pid . The process will continue as if it had never stopped.

Another way that the STOP signal can be “sent” is with the shell’s job control mechanism. Using the korn shell, a ^Z (ctrl-z) sent to a process sends the process a SIGSTOP and returns you to the shell. The fg shell command puts the command in the foreground and sends it a SIGCONT. The bg is the same but continues the program in the background. Thus, when a long running process is started in the foreground, and you get tired of waiting – send it a ^z and use bg to put it into the background.

Another way to send signals is by using the pkill command. This is a newer command, apparently introduced in Solaris 7, and now found in HP-UX, OpenBSD, Linux, and probably others. The command pkill is like kill, but allows searching for processes by their attributes (such as userid, terminal, group, state, or even a regular expression) and sends the signal to all that match. Being a newer command, it is best to check the man page for exact syntax.

Yet another signal: EXIT. This is not actually a signal, but is treated by one by some shells (including the Korn Shell). This uses signal 0, and is recognized by the shell’s trap command. Thus, using a trap command with a signal 0 permits the shell to execute things when it exits (such as file cleanup).