How to run a shell program

1
Processing Environment
2
Process ID

• Associated with each process is a unique positive
  integer identification number called a process ID
  (PID)
• In a Solaris environment
• Process 0 is sched
• Process 1 init, and
• Process 2 pageout
• The maximum value for process Ids can be found
  as the defined constant, MAXPID, in the header
  file ltsys/param.hgt
• The system call getpid can be used to obtain the
  process ID

3
getpid system call
4
Parent Process ID

• Every process has an associated parent process ID
  (PPID)
• The parent process is the process that forked the
  child process

5
getppid system call
6
Process Group ID

• Every process belongs to a process group that is
  identified by an integer process group ID value
• The initial parent process is known as the
  process leader
• The process leaders process ID will be the same
  as its process group ID
• Should a process group leader receive a kill or
  hang-up signal causing it to terminate, then all
  processes in its group will also be passed the
  same terminating signal

7
getpgid system call
8
Displaying Process Group ID

• To view prg 2.1, click here

• a.out
• Initial process PID 5003 PPID
  4995 GID 4995
• New process PID 5004 PPID
  5003 GID 4995
• New process PID 5005 PPID
  5004 GID 4995
• New process PID 5007 PPID
  5005 GID 4995
• New process PID 5008 PPID
  5004 GID 4995
• New process PID 5006 PPID
  5003 GID 4995
• New process PID 5009 PPID
  5006 GID 4995
• New process PID 5010 PPID
  5003 GID 4995

9
Process ID relationships
4995
Initial process process leader
Process Group 4995
5003
5004
5006
5010
5005
5008
5009
5007
10
Process Group ID (continue.)

• If the parent of a process dies (terminates), the
  process init (which is process ID 1) will inherit
  the process and become its foster parent
• The process group ID for a process does not
  change if this inheritance occurs

11
setpgid system call

• if the value for its pid is 0, the call refers
  to the current process
• If the value for pgrp is 0, the pid referenced
  process will become the process leader

12
Permissions

• The permissions are grouped into three sets of
  three bits each
• Each bit within a set determines if a file can be
  read, written to or executed

13
File permissions as octal values
read write execute
read write execute
read write execute
22 21 20
22 21 20
22 21 20
761
1 1 1
1 1 1
1 1 1
420
421
001
group
owner
other
14
File permissions displayed by ls

• ls -l file
• -rwxr-xr-x 1 sbenayed 400 43 Feb 9
  2248 file

15
Permissions (continue.)

• When the file is a directory
• setting the read bit indicates the directory can
  read or displayed
• Setting the write bit indicates files or links
  can be added or removed from the directory, and
• Setting execute permission indicates traversal
  permission is granted
• When generating files in UNIX, the operating
  system will assign permissions to the file
• The default permissions assigned to the file are
  determined by a bitwise operation on two
  three-digit octal mask

16
Permissions (continue.)

• These mask values are
• creation mask, and
• the umask
• The creation mask used by the system is 777 for
  executable and directory files and 666 for text
  files
• The default umask value is set by the system
  administrator and is most commonly 022
• At a system level the current umask value may be
  displayed/modified by using the umask command

17
Permissions (continue.)

• Example 1

• umask
• 0022
• umask 011
• umask
• 0011
• cat gt foo
• hello foo
• ls -l foo
• -rwxr-xr-x 1 sbenayed 400 10 Feb 27
  2343 foo

18
Permissions (continue.)

• Example 2

• mkdir bar
• ls -ld bar
• drwxr-xr-x 2 sbenayed 400 512 Feb 27
  2348 bar

19
Real and Effective User and Group IDs

• The real user ID (UID) and real group ID (GID)
  for the user are obtained from the third and
  forth fields of the password entry for the user
• For every process the system also keeps a second
  sets of Ids called effective IDs,
• the effective user ID (EUID), and
• effective group ID (EGID)
• The operating system will use the real Ids to
  identify the real user for things such as process
  accounting or sending mail, and
• the effective Ids to determine what additional
  permissions should be granted to the process

20
Real and Effective User and Group Ids
(continue.)

• To allow controlled access to key files, UNIX has
  an additional set of file permissions (known as
  set-user-ID (SUID) and set-group ID (SGID) that
  can be specified by the files owner
• These permissions tell the operating system that,
  when the program is run, the resulting process
  should have the privileges of the owner/group of
  the program

21
Real and Effective User and Group Ids
(continue.)

• The letter s in the owners category, found in
  place of the letter x, indicates that when this
  program is run, the process should have the
  privileges of the file owner (which is root)
• The set-user information is stored by the system
  in a tenth permission bit and can be modified
  using the system level command, chmod
• While a file can belong to only one group, a user
  can belong to many groups

22
user/group real and effective ID system call
23
Process/system file relationships
Parent Process
Child Process
text data stack
text data stack
User Space
u area
Process File Tables
stack
stack
Kernel Space
0 1 2 3
0 1 2 3
System File Table
System Inode Table
24
Real and Effective User and Group Ids (continue.)

• id
• uid8265(sbenayed) gid400

25
File Information

• The lstat system call is similar to stat except
  when the file referenced is a symbolic link
• The fstat system call takes an integer file
  descriptor value of an open file as its first
  argument
• All three stat system calls return, via their
  second argument, a pointer to a stat structure

26
stat system call
27
The stat structure
struct stat dev_t st_dev / device
file resides on / ino_t st_ino
/ this files number/ mode_t st_mode /
protection/ nlink_t st_nlink / number
of hard links to the file /
uid_t st_uid / user ID of owner /
gid_t st_gid / group ID of owner /
dev_t st_rdev / the device of identifier /
off_t st_size / total size of file, in
bytes / timestruc_t st_atim / file
data last access time / timestruc_t
st_mtim / file data last modify time /
blksize_t st_blksize / file data last
status change time/ blkcnt_t
st_blocks / preferred blocksize for file
system/ char
st_fstype_ST_FSTYPSZ /actual number of
blocks allocated blocks/
28
Using stat system call

• To see how to use stat system call, click here

a.out a.out Permissions for a.out rwxr-xr-x
ls -l a.out -rwxr-xr-x 1 sbenayed 400
7452 Mar 3 0937 a.out
29
File Information (continue.)

• In a programming environment, the access
  permissions of a file can be modified with the
  chmod/fchmod system calls

30
chmod/fchmod system call
31
File Information (continue.)

• Unless the effective process ID of the process is
  that of the superuser, the effective user ID and
  the owner of the file whose permissions are to be
  changed must be the same
• The umask value, which is inherited from the
  parent process, may be modified by a process with
  the umask system call

32
umask system call
33
File Information (continue.)

• When invoked, umask both changes the umask value
  to the integer value passed and returns the old
  (previous) umask value
• The library function getcwd is used to find the
  current working directory of a process
• The first argument is a pointer to the location
  where the pathname should be stored. If this
  argument is set to NULL, getcwd will use malloc
  to automatically allocate storage space
• The second argument is the length of the pathname
  to be returned (plus 1 for the \0 to terminate
  the string)

34
getcwd system call
35
File Information (continue.)

• The system call chdir is used to change the
  current working directory

36
chdir/fchdir system call
37
Process Resource Limits

• Every process is restrained by certain operating
  system imposed limits
• The limit command displays the resource maximums
  for the following categories
• cputime -number of cpu seconds allowed for the
  process
• filesize -size (number of bytes) when generating
  a single file
• datasize -the data plus stack segment size
• coredumpsize -core dump file size
• descriptors -the number of file descriptors

38
Process Resource Limits (continue.)

• limit -h
• cputime unlimited
• filesize unlimited
• datasize unlimited
• stacksize unlimited
• coredumpsize unlimited
• descriptors 1024
• memorysize unlimited
• limit
• cputime unlimited
• filesize unlimited
• datasize unlimited
• stacksize 8192 kbytes
• coredumpsize 0 kbytes
• descriptors 256
• memorysize unlimited

39
ulimit system call
40
Process Resource Limits (continue.)

• The argument cmd can take one of four different
  values
• Obtain file size limit for this process. The
  value returned is in units of 512 byte blocks
• Set the file size limit to the value indicated by
  newlimit. Non-superusers argument can decrease
  the file size limit. This is the only command in
  which the argument newlimit is used
• Obtain the maximum break value
• Obtain the maximum size of the file descriptor
  table for the process

41
Process Resource Limits (continue.)

• The newer getrlimit/setrlimit system calls
  provide the process more complete access to
  system resource limits

42
getrlimit/setrlimit system call
43
Process Resource Limits (continue.)

• The rlimit structure
• struct rlimit
• int rlim_cur / current (soft limit) /
• int rlim_max / hard limit/
• Along with a number of defined constants used by
  the two functions
• define RLIMIT_CPU 0 / cpu time in milliseconds
  /
• define RLIMIT_FSIZE 1 / maximum file size in
  bytes /
• define RLIMIT_DATA 2 / data size in bytes /
• define RLIMIT_STACK 3 / stack size in bytes /

44
Process Resource Limits (continue.)

• define RLIMIT_CORE 4 / core file size in
  bytes
• /
• define RLIMIT_RSS 5 / resident set size in
• bytes /
• define RLIMIT_NOFILE 6 / maximum descriptor
• index1 /
• define RLIMIT_NLIMITS 7 / number of resource
• limits /
• define RLIM_INFINITY 0x7fffffff / actual
  value of unlimited /

45
Process Resource Limits (continue.)

• To view how to display resource limit
  information, click here

a.out CPU time Current
2147483647 Max 2147483647 File size
Current 2147483647 Max
2147483647 Data segment Current
2147483647 Max 2147483647 Stack segment
Current 8388608 Max
2147483647 Core size Current
0 Max 2147483647 Resident set size
Current 256 Max
1024 File descriptors Current
2147483647 Max 2147483647
46
Process Resource Limits (continue.)

• Additional process limit information can be
  obtained from the sysconf library function

47
sysconf system call
48
Process Resource Limits (continue.)

• / WARNING _SC_CLK_TCK and sysconf() are also
  defined / declared in lttime.hgt /
• define _SC_ARG_MAX 1 /space for argv envp/
• define _SC_CHILD_MAX 2 /max children per
  process/
• define _SC_CLK_TCK 3 /clock ticks / sec /
• define _SC_NGROUPS_MAX 4 / numb of groups if
  supp/
• define _SC_OPEN_MAX 5 / max open files per
  process /
• define _SC_JOB_CONTROL 6 / do we have job
  control /
• define _SC_SAVED_VERSION 7 / do we have saved
  uid/gid /
• define _SC_VERSION 8 / POSIX version supported
  /

49
Process Resource Limits (continue.)

• To view how to display system limits, click here

a.out Max size of argv envp
1048320 Max of child processes
3909 Ticks / second 100 Max
of groups 16 Max of open
files 256 Job control supported?
1 Saved IDs supported?
1 Version of POSIX supported 199506
50
Signaling Processes

• Signals are generated when an event occurs that
  requires attention
• They may be generated by various sources
• Hardware-Such as when a process attempts to
  access addresses outside its own address space or
  divides by zero
• Kernel-Notifying the process that an I/O device
  for which it has been waiting (say, input from
  the terminal) is available
• Other processes-A child process notifying its
  parent process that it has terminated
• User-Pressing keyboard sequences that generate a
  quit, interrupt or stop signal

51
Signaling Processes (continue.)

• The process that receives a signal can take one
  of the three courses of action
• Perform the system-specified default for the
  signal
• Ignore the signal
• Catch the signal
• A child process inherits the actions associated
  with specific signals from its parent
• In most cases (except for I/O on slow devices
  such as the terminal) when a process is executing
  a system call and a signal is received, the
  interrupted system call will generate an error
  (usually returning 1) and set the global errno
  variable to the value EINTR

52
Command Line Values

• Part of the processing environment of every
  process are the values passed to the process in
  the function main
• To view how to display the content of the command
  line, click here

a.out this is a test a.out this is a test
53
getopt system call
54
Command Line Values (continue.)

• The getopt function requires three arguments
• The first is an integer value argc (the number of
  elements in the second argument)
• The second argument is a pointer to a pointer to
  a character (usually this is the array of
  character strings referenced by argv)
• The third argument is a pointer to a string of
  valid option letters (characters) that getopts
  should recognize
• If an option letter expects a following argument,
  the option letter in optstring is followed by a
  colon

55
Command Line Values (continue.)

• For example, if the option letter s (which,
  say, stands for size) is followed by an integer
  size value, the corresponding opstring entry
  would be s
• The getopt function will return, as an integer,
  one of three values
• -1 indicating all options have been processed, or
  the first non-option argument has been reached
• ? Indicating an option letter has been processed
  that was not in the opstring or an option
  argument was specified but none was found when
  processing the command line

56
Command Line Values (continue.)

• The next option letter in argv that matches a
  letter in optstring. If the letter matched in
  optstring is followed by a colon, then the
  external character pointer optarg will reference
  the argument value
• The external integer optind is initialized by the
  system to 1 before the first call to getopt
• It will contain the index of the next argument in
  argv to be processed
• A comparison of the value in optind to the value
  in argc can be used to determine if all items on
  the command line have been processed

57
Command Line Values (continue.)

• To view how to use getopt, click here

a.out -abc -s 34 -b joe -a Found option a Found
option b Found an option that was not in
optstring Found option s with an argument of
34 Found option b Left off at joe
58
Environment Variables

• Environment variables can be processed in a
  program by using an external pointer called
  environ which is defined as
• extern char environ
• To view ho to display environment variables,
  click here

. . . /usr/local/TeX/bin/usr/include/usr/local/n
etpbm/usr/local/psutils/usr/local/jd k/bin/usr/
openwin/bin/usr/openwin/include/usr/openwin/lib
/usr/local/pvm3/lib /usr/local/pvm3/lib/SUN4SOL2
/home/sbenayed/pvm3/bin/SUN4SOL2/u01/app/oracle/p
roduct/8.1.6/bin PVM_ROOT/usr/local/pvm3 PWD/ho
me/sbenayed SHELL/bin/csh . . .
59
getenv system call
60
putenv system call
61
Environment Variables (continue.)

• The character string argument passed to getenv
  should be of the format name where name is the
  name of the environment variable to find with an
  appended
• Note that name is case sensitive
• To view how to use getenv, click here

a.out The variable TERM is vt100
62
Environment Variables (continue.)

• To view how to use putenv, click here

. . . 20E8C USERsbenayed 20E90
XPVM_ROOT/usr/local/pvm3/xpvm 20E94
_INIT_NET_STRATEGYnone 20E98
_INIT_PREV_LEVELS 20E9C _INIT_RUN_LEVEL3
20EA0 _INIT_RUN_NPREV0 20EA4
_INIT_UTS_ISAsparc 20EA8 _INIT_UTS_MACHINEs
un4u 20EAC _INIT_UTS_NODENAMEegypt
20EB0 _INIT_UTS_PLATFORMSUNW,Ultra-5_10
20EB4 _INIT_UTS_RELEASE5.8 20EB8
_INIT_UTS_SYSNAMESunOS 20EBC
_INIT_UTS_VERSIONGeneric 20EC0
PARENT_EDparent ... and at address 20EC4 is
... Nothing!
63
Environment Variables (continue.)

• There several important concepts that can be
  gained by examining this program and its output
• it is clear that the addresses associated with
  the environment variables are changed (from the
  stack segment to the text segment) when a new
  environment variable is added
• The child process inherits a copy of the
  environment variables from its parent
• As each process has its own address space, it is
  not possible to pass information back to parent
  process from a child process

64
Environment Variables (continue.)

• 4. When adding an environment variable, the
  namevalue format should adhered to. While it is
  not checked in the program, putenv will return a
  0 if it is successful and a non-zero value if it
  fails to accomplish its mission

65
References

• INTERPROCES COMMUNICATIONS IN UNIX BY J. GRAY
• UNIX SYSTEM PROGRAMMING BY K.HAVILAND, D. GRAY
  AND B. SALAMA