|Commonly used QNX Commands
Author : Ram Mohan
ATIC Document : LSU 98-03
Version : March 05, 1998
This document contains a list of commands that are commonly used when working on the QNX Operating System.
1) QNX Operating System Utilities - A to M
2) QNX Operating System Utilities - N to Z
To print the name of the current working directory $ pwd
2. To list all files in current directory $ ls
To list all files including those that $ ls -al
begin with a ‘.’
4. To list only directories in current directory $ ls -d
To list files and directories with a ‘/’ character
appended only to directories. This command $ ls -CF
also lists all executable files with a ‘*’ character at the end.
Eg. a.out*, exefile*
To define an alias for a command $ alias dir=’ls -l’
The alias must be defined in the .profile file which is present
in the login directory. The directory into which the user enters
soon after the password verification is called the login directory.
The .profile file gets executed during each successful login.
After the alias is defined in the .profile file, it has to be executed
the first time for the alias to work. The .profile file is
executed at the prompt with $ . .profile
To get usage and options on any valid command $ use cmdname
To find out the PATH environment variable $ echo $PATH
To set a new path $ PATH=newpath
To add a directory to existing PATH
Here /usr/local/bin is added to the existing path. Each path variable is separated by a ‘:’
File Handling Commands
To display a file without going into edit mode $ cat filename
To display a file one screen at a time $ more filename
To Page Up/Down, use the
Page Up / Page Down keys.
To copy a file $ cp srcfile destfile
While copying absolute OR relative path can be used.
Absolute path begins from root (/)
e.g. : /usr/home/atic
Relative path begins from current working directory
e.g.. If atic and user1 are directories under /usr/home,
to copy a file ‘somefile.c’ in the user1 directory
from the atic directory, the command would be
$ cp ../user1/somefile.c myfile.c
4. To rename/move a file $ mv srcfile destfile
Path same as for copy command
5. To delete a file $ rm filename
The -i option of copy and delete commands prompt
the user before performing the operation $ cp -i
$ rm -i
To create a directory $ mkdir dirname
8. To remove an empty directory $ rmdir dirname
9. To remove a directory recursively $ rm -r dirname
10. To search for a file in the file system $ find path -name “filename”
The path can be from root (/) or any
valid search directory
e.g.. To search for a file ‘cdf.h’ in the file system
the command is $ find / -name “cdf.h”
To search in the directory /usr and directories only under /usr the command is
$ find /usr -name “cdf.h”
To search for a pattern in a file/set of files $ grep pattern file/files
ex : grep msg *.c searches for pattern msg
in all .c files of current directory
To compare contents of 2 files $ diff file1 file2
13. To change directory $ cd destdir
destdir can again be specified as absolute path
OR relative path
C Program Compilation/Linking/Execution
To compile and link a .c program in a single command $ cc srcfile
This command will create an executable file name
To compile, link and create an object file $ cc -o execfile srcfile
of different name
To compile only $ cc -c srcfile
To change modes of a file $ chmod mode filename
The modes of any file determine the usage and accessibility rights. Every file has 3 kinds of modes namely READ mode, WRITE mode and EXECUTE mode. These modes when set, enable the respective operation on the file. These 3 modes can be individually set for 3 classes of users namely OWNER, GROUP and OTHERS. The ‘ls -l’ command displays the current mode for each file in the directory. A sample output for the command ‘ls -l’ is
-rw- rw- r-- atic label 2245 Feb 27 1998 somefile.c
-rwx rwx r-x atic label 3456 Feb 28 1998 a.out
owner group others
A ‘-‘ in the first column indicates that somefile.c is a file. A ‘d’ character takes its place when the file is a directory. In the above listing, ‘atic’ denotes the owner and ‘label’ the group. Each set of rwx corresponds to READ, WRITE and EXECUTE respectively. The first set of rwx entry specifies permissions to the owner, the second set to the group and third set to others respectively. Permissions for the group implies permissions for all users who belong to the same group as the owner. A ‘-‘ for any permission indicates that the particular mode of operation is not permitted.
In the above output, Owner and group for ‘somefile.c’ have Read/Write permissions while others have Read permission only. Similarly for ‘a.out’ owner and group have Read/Write/Execute permissions while others have only Read/Execute permission.
The ‘chmod’ command is very useful when scripts (equivalent to batch files in DOS) written by the user need to be made executables. All required commands can be included in the script file and the mode of the script file changed to allow execution.
The file mode can be changed by using the +/- feature. To set a particular mode the ‘+’ with required permission is used. A ‘-‘ will remove the permission. Owner group and others are specified using ‘u’, ‘g’ and ‘o’ respectively.
eg.. chmod u+x a.out
This will set execute permission to the user.
eg.. chmod go-w somefile.c
This will remove write permission to group and others.
eg. chmod ugo+r-x somefile.c
This command will give read permission to owner, group and others and remove the execute permission to all of them.
5. To create and use shell script files.
An example of a script file is shown below. Suppose we want to write a script file that builds an executable from 2 functions in 2 different files. Let the name of the script file be mycc.
$ cat mycc
# A comment begins with a ‘#’ character in a script file, The first line creates a sub shell
# to execute the script
cc -o$1 $2 $3
The contents of file mycc are shown above. To use this script file it has to first be converted to an executable with the command
$ chmod u+x mycc
Now let the two C functions be in files mainfile.c and secfile.c To use the above script file the command will be
$ mycc mainfile.c secfile.c
The script interprets arguments mycc as $0, as $1, mainfile.c as $2 and secfile.c as $3.
The executable will be created in file .
The script file can be customized to user's requirement by using valid commands in the file and converting that into an executable script as shown above.
Another example is shown below.
$ cat mynewcc
cc -c $2.c $3.c $4.c
cc -o $1 $2.o $3.o $4.o
The contents of script file mynewcc is shown above. Here the user can specify files without the .c extension. The script adds the appropriate extension ( .c for compiling and .o for linking ) and builds the executable.
eg. $ newcc mainfile secfile thirdfile
In the above command, mainfile.c secfile.c and thirdfile.c are the source files and is the name of the executable file. As can be seen no extensions are specified.
6. To change ownership of a file $ chown [group:] owner filename
[ ] indicates optional.
To build a CDF Executable
The user PATH should contain the directory where the binaries for CDF are located. Typically the directory is ‘/usr/local/cdf26-dist/bin’. If the binaries are located in a different directory they can be found by using the ‘find’ command to search for file ‘libcdf.a’. This will give the ‘lib’ directory under cdf26-dist directory. The ‘lib’ entry should be replaced by ‘bin’ and the directory path should be included in the user’s PATH environment variable.
To compile a cdf source file
$ cc -c -I/usr/local/cdf26-dist/include
$ cc -o /usr/local/cdf26-dist/lib/libcdf.a
An example makefile is shown below
all: file1 file2
CFLAGS+= -2 -g
The above information is stored in a file called ‘Makefile’ and this file should be in the directory in which the source files to be compiled are present. In this example file1.c and file2.c are the source files for which the executables file1 and file2 are being built. CFLAGS and LDFLAGS contain the compile and link options respectively. A ‘#’ sign at the beginning of a line comments that line in the makefile. If no options are mentioned defaults are used.
To build an executable using Makefile, $ make
NOTE : Words in italics denote user input.
Commands used to work with Processes
To run a process in the background $ cmdname &
cmdname could be a qnx command or
a user defined process.
e.g: $ gse_mngr &
To obtain information about process running on the system currently $ sin
An output of the ‘sin’ command is shown below
SID PID PROGRAM PRI STATE BLK CODE DATA
-- -- Microkernel --- ----- --- 11696 0
0 1 sys/Proc32 30f READY --- 114k 950k
0 4 /bin/Fsys 29r RECV 0 77k 2609k
0 19 //2/bin/Dev32.ansi 20r RECV 0 40k 122k
0 23 //2/bin/Fsys.floppy 10o RECV 0 20k 40k
0 31 //2/bin/Net.ether8003 20r RECV 0 28k 28k
0 51 //2/bin/Mouse 10o RECV 0 16k 20k
0 56 //2/bin/cron 10o RECV 0 24k 20k
0 63 //2/bin/tinit 10o WAIT -1 16k 28k
1 8654 //2/bin/ksh 10o REPLY 16 17k 45k
2 30517 //2/*/10.6/bin/wcc386 9o READY --- 499k 184k
2 31001 //2/bin/cc 10o WAIT -1 24k 49k
2 31035 //2/bin/sin 10o REPLY 1 45k 49k
SID denotes the session ID, PID denotes the process ID, Program informs the name of the process, PRI the priority and STATE, the current state of the process. In the above output cc, wcc386, ksh, tinit and cron are examples of some processes. Any process can be killed (prematurely terminated) only with appropriate permissions.
3. To kill a process $ slay processname
eg. $ slay tinit
OR $ kill -9 PID
eg. $ kill -9 30517
Sometimes ‘slay’ may not work and ‘kill’ may have to be used.
To work on more than one terminal session.
Terminal sessions (screens) can be switched by pressing the Ctl+Alt+ keys simultaneously. When the system boots initially, session 1 is opened by default. Upto 6 sessions can be used simultaneously.
eg. Ctl+Alt+3 will take the user to the 3rd session. The user can switch back to the previous session any time.
To build a Photon application
1. From photon, select the "Dev. Tools" tab.
2. Click on "Application Builder" to open Photon Application Builder (PhAB).
To create a new application:
1. Select "File"->"New" from the PhAB menu.
2. Create the GUI for the application by dragging and dropping it onto the
dialog box. Save the application by using "File"->"Save As" from the PhAB menu.
To compile and link the application:
1. Select Application->Build+Run from the PhAB menu.
2. A dialog box pops up.
3. Click the "Generate" button from the dialog box to automatically generate the code for the application.
4. Click the "Make" button from the dialog box to compile and link the application. This creates the executable for the application.
5. To run the application, click "Run Application".
If we create an application called "app1", then a directory by the name of the application is created. Inside the "app1" directory, a directory structure as follows is created:
abapp.dfn - a file created by PhAB to store the configuration of the application.
Src - This directory contains all source code.
Default - Contains all object modules and executables.
wgt - Contains information of the graphical objects used in the application. This is created automatically by PhAB
The source code in the “src” directory can be modified by the user. After modification, the code needs to be re-compiled using the “Make” utility from the “Application” menu.
ATIC DOC LSU 98-03 4/25/2016 4/25/2016