Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
sh(1)				 User Commands				 sh(1)

NAME
       sh, jsh - standard and job control shell	and command interpreter

SYNOPSIS
       /usr/bin/sh [-acefhiknprstuvx] [argument...]

       /usr/xpg4/bin/sh	[ +- abCefhikmnoprstuvx] [ +- o	option...] [-c string]
       [arg...]

       /usr/bin/jsh [-acefhiknprstuvx] [argument...]

DESCRIPTION
       The /usr/bin/sh utility is a command programming	language that executes
       commands	read from a terminal or	a file.

       The /usr/xpg4/bin/sh utility is a standards compliant shell. This util-
       ity provides all	the functionality of ksh(1), except in cases discussed
       in ksh(1) where differences in behavior exist.

       The  jsh	 utility is an interface to the	shell that provides all	of the
       functionality of	sh and enables job control (see	 Job  Control  section
       below).

       Arguments to the	shell are listed in the	Invocation section below.

   Definitions
       A  blank	 is  a	tab or a space.	A name is a sequence of	ASCII letters,
       digits, or underscores, beginning with a	letter	or  an	underscore.  A
       parameter  is  a	name, a	digit, or any of the characters	*, @, #, ?, -,
       $, and !.

USAGE
   Commands
       A simple-command	is a sequence of non-blank words separated by  blanks.
       The first word specifies	the name of the	command	to be executed.	Except
       as specified below, the remaining words are passed as arguments to  the
       invoked	command.  The  command	name  is  passed  as  argument	0 (see
       exec(2)). The value of a	simple-command is its exit status if it	termi-
       nates  normally,	or (octal) 200+status if it terminates abnormally. See
       signal(3HEAD) for a list	of status values.

       A pipeline is a sequence	of one or more commands	separated  by  |.  The
       standard	 output	of each	command	but the	last is	connected by a pipe(2)
       to the standard input of	the next command. Each command	is  run	 as  a
       separate	 process.  The	shell waits for	the last command to terminate.
       The exit	status of a pipeline is	the exit status	of the last command in
       the pipeline.

       A list is a sequence of one or more pipelines separated by ;, &,	&&, or
       ||, and optionally terminated by	; or &.	Of these four symbols, ; and &
       have  equal precedence, which is	lower than that	of && and ||. The sym-
       bols && and || also have	 equal	precedence.  A	semicolon  (;)	causes
       sequential  execution  of  the  preceding  pipeline, that is, the shell
       waits for the pipeline to finish	before executing any commands  follow-
       ing  the	 semicolon.  An	ampersand (&) causes asynchronous execution of
       the preceding pipeline, that is,	the shell does not wait	for that pipe-
       line  to	 finish. The symbol && (||) causes the list following it to be
       executed	only if	the preceding pipeline returns a zero (non-zero)  exit
       status.	An  arbitrary number of	newlines may appear in a list, instead
       of semicolons, to delimit commands.

       A command is either a simple-command or one of  the  following.	Unless
       otherwise  stated,  the value returned by a command is that of the last
       simple-command executed in the command.

       for name	[ in word ... ]	do list	done
	     Each time a for command is	executed, name is set to the next word
	     taken  from the in	word list. If in word ... is omitted, then the
	     for command executes the do list once for each positional parame-
	     ter  that is set (see Parameter Substitution section below). Exe-
	     cution ends when there are	no more	words in the list.

       case word in [ pattern [	| pattern ] ) list ;; ]	...  esac
	     A case command executes the list associated with the  first  pat-
	     tern  that	 matches word. The form	of the patterns	is the same as
	     that used for file-name generation	(see File Name Generation sec-
	     tion),  except  that a slash, a leading dot, or a dot immediately
	     following a slash need not	be matched explicitly.

       if list ; then list ; [ elif list ; then	list ; ] ... [ else list  ;  ]
       fi

	      The list following if is executed	and, if	it returns a zero exit
	      status, the list following the first then	 is  executed.	Other-
	      wise,  the  list following elif is executed and, if its value is
	      zero, the	list following the  next  then	is  executed.  Failing
	      that, the	else list is executed. If no else list or then list is
	      executed,	then the if command returns a zero exit	status.

       while list do list done
	     A while command repeatedly	executes the while list	 and,  if  the
	     exit status of the	last command in	the list is zero, executes the
	     do	list; otherwise	the loop terminates. If	no commands in the  do
	     list  are	executed,  then	 the while command returns a zero exit
	     status; until may be used in place	of while to  negate  the  loop
	     termination test.

       (list)
	     Execute list in a sub-shell.

       { list;}
	     list  is  executed	 in the	current	(that is, parent) shell. The {
	     must be followed by a space.

       name () { list;}
	     Define a function which is	referenced by name. The	 body  of  the
	     function  is  the list of commands	between	{ and }. The { must be
	     followed by a space. Execution of functions  is  described	 below
	     (see Execution section).  The { and } are unnecessary if the body
	     of	the function is	a command as defined above, under Commands.

       The following words are only recognized as the first word of a  command
       and when	not quoted:

	if   then   else  elif	fi  case  esac	for  while  until  do  done  {
       }

   Comments Lines
       A word beginning	with # causes that word	and all	the following  charac-
       ters up to a newline to be ignored.

   Command Substitution
       The shell reads commands	from the string	between	two grave accents (``)
       and the standard	output from these commands may be used as all or  part
       of a word. Trailing newlines from the standard output are removed.

       No  interpretation  is  done  on	 the string before the string is read,
       except to remove	backslashes (\)	used to	escape other characters. Back-
       slashes	may  be	used to	escape a grave accent (`) or another backslash
       (\) and are removed before the command string is	read.  Escaping	 grave
       accents allows nested command substitution. If the command substitution
       lies within a pair of double quotes (" ...` ...`	...  "),  a  backslash
       used  to	escape a double	quote (\") will	be removed; otherwise, it will
       be left intact.

       If a backslash is used to escape	a newline character  (\newline),  both
       the  backslash  and  the	 newline are removed (see the later section on
       Quoting). In addition, backslashes used to escape dollar	signs (\$) are
       removed.	 Since no parameter substitution is done on the	command	string
       before it is read, inserting a backslash	to escape a dollar sign	has no
       effect.	Backslashes  that  precede characters other than \, `, ", new-
       line, and $ are left intact when	the command string is read.

   Parameter Substitution
       The character $ is used to introduce  substitutable  parameters.	 There
       are  two	types of parameters, positional	and keyword. If	parameter is a
       digit, it is a  positional  parameter.  Positional  parameters  may  be
       assigned	 values	 by  set. Keyword parameters (also known as variables)
       may be assigned values by writing:

	      name=value [ name=value ]	...

       Pattern-matching	is not performed on value. There cannot	be a  function
       and a variable with the same name.

       ${parameter}
	     The  value,  if  any, of the parameter is substituted. The	braces
	     are required only when parameter is followed by a letter,	digit,
	     or	 underscore that is not	to be interpreted as part of its name.
	     If	parameter is * or @, all the positional	 parameters,  starting
	     with  $1,	are substituted	(separated by spaces). Parameter $0 is
	     set from argument zero when the shell is invoked.

       ${parameter:-word}
	     If	parameter is set and is	non-null, substitute its value;	other-
	     wise substitute word.

       ${parameter:=word}
	     If	 parameter  is not set or is null set it to word; the value of
	     the parameter is substituted. Positional parameters  may  not  be
	     assigned in this way.

       ${parameter:?word}
	     If	parameter is set and is	non-null, substitute its value;	other-
	     wise, print word and exit from the	shell. If word is omitted, the
	     message "parameter	null or	not set" is printed.

       ${parameter:+word}
	     If	 parameter  is set and is non-null, substitute word; otherwise
	     substitute	nothing.

       In the above, word is not evaluated unless it is	to be used as the sub-
       stituted	 string,  so  that,  in	the following example, pwd is executed
       only if d is not	set or is null:

	      echo ${d:-`pwd`}

       If the colon (:)	is omitted from	the above expressions, the shell  only
       checks whether parameter	is set or not.

       The following parameters	are automatically set by the shell.

       #     The number	of positional parameters in decimal.

       -     Flags  supplied to	the shell on invocation	or by the set command.

       ?     The decimal value returned	by  the	 last  synchronously  executed
	     command.

       $     The process number	of this	shell.

       !     The process number	of the last background command invoked.

       The  following parameters are used by the shell.	The parameters in this
       section are also	referred to as environment variables.

       HOME  The default argument (home	directory) for the cd command, set  to
	     the  user's  login	 directory  by login(1)	from the password file
	     (see passwd(4)).

       PATH  The search	path for commands (see Execution section below).

       CDPATH
	     The search	path for the cd	command.

       MAIL  If	this parameter is set to the name of a mail file and the MAIL-
	     PATH   parameter  is  not	set, the shell informs the user	of the
	     arrival of	mail in	the specified file.

       MAILCHECK
	     This parameter specifies how often	(in seconds)  the  shell  will
	     check for the arrival of mail in the files	specified by the MAIL-
	     PATH or MAIL parameters. The default value	 is  600  seconds  (10
	     minutes). If set to 0, the	shell will check before	each prompt.

       MAILPATH
	     A	colon-separated	 list of file names. If	this parameter is set,
	     the shell informs the user	of the arrival of mail in any  of  the
	     specified	files.	Each file name can be followed by % and	a mes-
	     sage that will be printed when the	modification time changes. The
	     default message is, you have mail.

       PS1   Primary prompt string, by default " $ ".

       PS2   Secondary prompt string, by default " > ".

       IFS   Internal  field separators, normally space, tab, and newline (see
	     Blank Interpretation section).

       SHACCT
	     If	this parameter is set to the name of a file  writable  by  the
	     user,  the	 shell will write an accounting	record in the file for
	     each shell	procedure executed.

       SHELL When the shell is invoked,	it scans the environment (see Environ-
	     ment section below) for this name.

       See  environ(5) for descriptions	of the following environment variables
       that affect the execution of sh:	LC_CTYPE and LC_MESSAGES.

       The shell gives default values to PATH, PS1, PS2, MAILCHECK,  and  IFS.
       Default values for HOME and MAIL	are set	by login(1).

   Blank Interpretation
       After  parameter	 and command substitution, the results of substitution
       are scanned for internal	field separator	 characters  (those  found  in
       IFS) and	split into distinct arguments where such characters are	found.
       Explicit	null arguments ("" or '') are retained.	 Implicit  null	 argu-
       ments  (those  resulting	 from  parameters  that	 have  no  values) are
       removed.

   Input/Output	Redirection
       A command's input and output may	be redirected using a special notation
       interpreted  by	the shell. The following may appear anywhere in	a sim-
       ple-command or may precede or follow a command and are not passed on as
       arguments to the	invoked	command. Note: Parameter and command substitu-
       tion occurs before word or digit	is used.

       <word Use file word as standard input (file descriptor 0).

       >word Use file word as standard output (file descriptor 1). If the file
	     does not exist, it	is created; otherwise, it is truncated to zero
	     length.

       >>word
	     Use file word as standard output. If the file exists,  output  is
	     appended  to  it by first seeking to the EOF. Otherwise, the file
	     is	created.

       <>word
	     Open file word for	reading	and writing as standard	input.

       <<[-]word
	     After parameter and command substitution is  done	on  word,  the
	     shell  input  is read up to the first line	that literally matches
	     the resulting word, or to an EOF. If, however, the	hyphen (-)  is
	     appended to <<:

	     1.	leading	 tabs are stripped from	word before the	shell input is
		read (but after	parameter and command substitution is done  on
		word);

	     2.	leading	 tabs  are stripped from the shell input as it is read
		and before each	line is	compared with word; and

	     3.	shell input is read  up	 to  the  first	 line  that  literally
		matches	the resulting word, or to an EOF.

       If  any	character  of  word  is	quoted (see Quoting section later), no
       additional processing is	done to	the shell input. If no	characters  of
       word are	quoted:

	     1.	parameter and command substitution occurs;

	     2.	(escaped) \newlines are	removed; and

	     3.	\ must be used to quote	the characters \, $, and `.

	     The resulting document becomes the	standard input.

       <&digit
	     Use  the  file  associated	with file descriptor digit as standard
	     input. Similarly for the standard output using >&digit.

       <&-   The standard input	is closed. Similarly for the  standard	output
	     using >&-.

       If  any	of the above is	preceded by a digit, the file descriptor which
       will be associated with	the  file  is  that  specified	by  the	 digit
       (instead	of the default 0 or 1).	For example:

       ... 2>&1

       associates  file	 descriptor  2 with the	file currently associated with
       file descriptor 1.

       The order in which redirections are specified is	significant. The shell
       evaluates redirections left-to-right. For example:

       ... 1>xxx 2>&1

       first  associates  file	descriptor 1 with file xxx. It associates file
       descriptor 2 with the file associated with file descriptor 1 (that  is,
       xxx).  If  the  order  of redirections were reversed, file descriptor 2
       would be	associated with	the terminal (assuming file descriptor	1  had
       been) and file descriptor 1 would be associated with file xxx.

       Using  the terminology introduced on the	first page, under Commands, if
       a command is composed of	several	simple commands, redirection  will  be
       evaluated for the entire	command	before it is evaluated for each	simple
       command.	That is, the shell evaluates redirection for the entire	 list,
       then each pipeline within the list, then	each command within each pipe-
       line, then each list within each	command.

       If a command is followed	by &, the default standard input for the  com-
       mand  is	 the empty file, /dev/null. Otherwise, the environment for the
       execution of a command contains the file	descriptors  of	 the  invoking
       shell as	modified by input/output specifications.

   File	Name Generation
       Before  a  command  is  executed,  each command word is scanned for the
       characters *, ?,	and [. If one of these characters appears the word  is
       regarded	 as a pattern. The word	is replaced with alphabetically	sorted
       file names that match the pattern.  If  no  file	 name  is  found  that
       matches the pattern, the	word is	left unchanged.	The character .	at the
       start of	a file name or immediately following a /, as well as the char-
       acter / itself, must be matched explicitly.

       *     Matches any string, including the null string.

       ?     Matches any single	character.

       [...] Matches  any one of the enclosed characters. A pair of characters
	     separated by - matches any	character lexically between the	 pair,
	     inclusive.	If the first character following the opening [ is a !,
	     any character not enclosed	is matched.

       Notice that all quoted characters (see below) must be  matched  explic-
       itly in a filename.

   Quoting
       The  following characters have a	special	meaning	to the shell and cause
       termination of a	word unless quoted:

       ;  &  (	)  |  ^	 <  >  newline	space  tab

       A character may be quoted (that is, made	to stand for itself)  by  pre-
       ceding  it with a backslash (\) or inserting it between a pair of quote
       marks ('' or ""). During	processing, the	shell may quote	certain	 char-
       acters  to  prevent  them from taking on	a special meaning. Backslashes
       used to quote a single character	are removed from the word  before  the
       command	is  executed.  The pair	\newline is removed from a word	before
       command and parameter substitution.

       All characters enclosed between a pair  of  single  quote  marks	 (''),
       except  a  single quote,	are quoted by the shell. Backslash has no spe-
       cial meaning inside a pair of single quotes.  A	single	quote  may  be
       quoted  inside  a  pair of double quote marks (for example, "'"), but a
       single quote can	not be quoted inside a pair of single quotes.

       Inside a	pair of	double quote marks (""), parameter and command substi-
       tution occurs and the shell quotes the results to avoid blank interpre-
       tation and file name generation.	If $*  is  within  a  pair  of	double
       quotes, the positional parameters are substituted and quoted, separated
       by quoted spaces	("$1 $2	..."). However,	if $@ is within	a pair of dou-
       ble quotes, the positional parameters are substituted and quoted, sepa-
       rated by	unquoted spaces	("$1""$2"  ... ). \ quotes the	characters  \,
       `,  , (comma), and $. The pair \newline is removed before parameter and
       command substitution. If	a backslash precedes characters	other than  \,
       `,  ,  (comma),	$, and newline,	then the backslash itself is quoted by
       the shell.

   Prompting
       When used interactively,	the shell prompts with the value of PS1	before
       reading	a command. If at any time a newline is typed and further input
       is needed to complete a command,	the secondary  prompt  (that  is,  the
       value of	PS2) is	issued.

   Environment
       The  environment	(see environ(5)) is a list of name-value pairs that is
       passed to an executed program in	the same  way  as  a  normal  argument
       list.  The  shell  interacts  with  the environment in several ways. On
       invocation, the shell scans the environment and creates a parameter for
       each  name found, giving	it the corresponding value.  If	the user modi-
       fies the	value of any of	these parameters or  creates  new  parameters,
       none of these affects the environment unless the	export command is used
       to bind the shell's parameter to	the environment	(see also set  -a).  A
       parameter  may  be removed from the environment with the	unset command.
       The environment seen by any executed command is thus  composed  of  any
       unmodified  name-value  pairs  originally inherited by the shell, minus
       any pairs removed by unset, plus	any modifications or additions,	all of
       which must be noted in export commands.

       The environment for any simple-command may be augmented by prefixing it
       with one	or more	assignments to parameters. Thus:

       TERM=450	 command

       and

       (export TERM; TERM=450;	 command

       are equivalent as far as	the execution of command is concerned if  com-
       mand is not a Special Command. If command is a Special Command, then

       TERM=450	  command

       will modify the TERM variable in	the current shell.

       If the -k flag is set, all keyword arguments are	placed in the environ-
       ment, even if they occur	after the command name.	The following  example
       first prints a=b	c and c:

       echo a=b	 c

       a=b  c

       set  -k

       echo a=b	 c

       c

   Signals
       The  INTERRUPT  and  QUIT signals for an	invoked	command	are ignored if
       the command is followed by &. Otherwise,	signals	have the values	inher-
       ited by the shell from its parent, with the exception of	signal 11 (but
       see also	the trap command below).

   Execution
       Each time a command is executed,	the  command  substitution,  parameter
       substitution, blank interpretation, input/output	redirection, and file-
       name generation listed above are	 carried  out.	If  the	 command  name
       matches the name	of a defined function, the function is executed	in the
       shell process (note how this differs from the execution of shell	script
       files,  which  require a	sub-shell for invocation). If the command name
       does not	match the name of a defined function, but matches one  of  the
       Special Commands	listed below, it is executed in	the shell process.

       The  positional	parameters $1, $2, ... are set to the arguments	of the
       function. If the	command	name matches neither a Special Command nor the
       name  of	a defined function, a new process is created and an attempt is
       made to execute the command via exec(2).

       The shell parameter PATH	defines	the search path	for the	directory con-
       taining	the  command.  Alternative  directory names are	separated by a
       colon (:). The default path is /usr/bin.	The current directory is spec-
       ified by	a null path name, which	can appear immediately after the equal
       sign, between two colon delimiters anywhere in the path list, or	at the
       end  of the path	list. If the command name contains a / the search path
       is not used. Otherwise, each directory in the path is searched  for  an
       executable file.	If the file has	execute	permission but is not an a.out
       file, it	is assumed to be a file	containing shell commands. A sub-shell
       is  spawned  to	read it. A parenthesized command is also executed in a
       sub-shell.

       The location in the search path where a command was found is remembered
       by  the	shell  (to help	avoid unnecessary execs	later).	If the command
       was found in a relative directory, its location must  be	 re-determined
       whenever	 the  current  directory changes. The shell forgets all	remem-
       bered locations whenever	the PATH variable is changed or	 the  hash  -r
       command is executed (see	below).

   Special Commands
       Input/output  redirection  is  now  permitted  for these	commands. File
       descriptor 1 is the  default  output  location.	When  Job  Control  is
       enabled,	 additional Special Commands are added to the shell's environ-
       ment (see Job Control section below).

       :     No	effect;	 the  command  does  nothing.  A  zero	exit  code  is
	     returned.

       . filename
	     Read  and	execute	 commands from filename	and return. The	search
	     path specified by PATH is used to find the	 directory  containing
	     filename.

       bg [%jobid ...]
	     When  Job	Control	 is  enabled,  the  bg command is added	to the
	     user's environment	to manipulate jobs. Resumes the	execution of a
	     stopped  job  in the background. If %jobid	is omitted the current
	     job is assumed. (See Job Control section below for	more  detail.)

       break [ n ]
	     Exit from the enclosing for or while loop,	if any.	If n is	speci-
	     fied, break n levels.

       cd [ argument ]
	     Change the	current	directory to  argument.	 The  shell  parameter
	     HOME  is the default argument. The	shell parameter	CDPATH defines
	     the search	path for the directory containing  argument.  Alterna-
	     tive  directory  names  are separated by a	colon (:). The default
	     path is <null> (specifying	the current directory).	Note: The cur-
	     rent directory is specified by a null path	name, which can	appear
	     immediately after the equal sign or between the colon  delimiters
	     anywhere  else  in	the path list. If argument begins with a / the
	     search path is not	used. Otherwise, each directory	in the path is
	     searched for argument.

       chdir [ dir ]
	     chdir  changes the	shell's	working	directory to directory dir. If
	     no	argument is given, change to the home directory	of  the	 user.
	     If	dir is a relative pathname not found in	the current directory,
	     check for it in those directories listed in the CDPATH  variable.
	     If	 dir is	the name of a shell variable whose value starts	with a
	     /,	change to the directory	named by that value.

       continue	[ n ]
	     Resume the	next iteration of the enclosing	for or while loop.  If
	     n is specified, resume at the n-th	enclosing loop.

       echo [ arguments	... ]
	     The  words	 in arguments are written to the shell's standard out-
	     put, separated by space characters. See echo(1) for fuller	 usage
	     and description.

       eval [ argument ... ]
	     The  arguments  are  read as input	to the shell and the resulting
	     command(s)	executed.

       exec [ argument ... ]
	     The command specified by the arguments is executed	 in  place  of
	     this shell	without	creating a new process.	Input/output arguments
	     may appear	and, if	no other arguments are given, cause the	 shell
	     input/output to be	modified.

       exit [ n	]
	     Causes  the  calling  shell or shell script to exit with the exit
	     status specified by n. If n is omitted the	exit status is that of
	     the  last	command	 executed (an EOF will also cause the shell to
	     exit.)

       export [	name ... ]
	     The given names are marked	for automatic export to	 the  environ-
	     ment  of  subsequently  executed  commands.  If  no arguments are
	     given, variable names that	have been marked for export during the
	     current  shell's  execution  are listed. (Variable	names exported
	     from a parent shell are listed only if they  have	been  exported
	     again  during  the	current	shell's	execution.) Function names are
	     not exported.

       fg [%jobid ...]
	     When Job Control is enabled, the  fg  command  is	added  to  the
	     user's  environment  to manipulate	jobs. This command resumes the
	     execution of a stopped job	in the foreground and  also  moves  an
	     executing	background job into the	foreground. If %jobid is omit-
	     ted, the current job is assumed. (See Job Control	section	 below
	     for more detail.)

       getopts
	     Use  in  shell  scripts  to support command syntax	standards (see
	     intro(1)).	This command parses positional parameters  and	checks
	     for legal options.	See getoptcvt(1) for usage and description.

       hash [ -r ] [ name ... ]
	     For  each	name,  the  location in	the search path	of the command
	     specified by name is determined and remembered by the shell.  The
	     -r	option causes the shell	to forget all remembered locations. If
	     no	arguments are given, information about remembered commands  is
	     presented.	Hits is	the number of times a command has been invoked
	     by	the shell process. Cost	is a measure of	the work  required  to
	     locate  a	command	in the search path. If a command is found in a
	     "relative"	directory in the search	path, after changing  to  that
	     directory,	 the  stored location of that command is recalculated.
	     Commands for which	this will be done are indicated	by an asterisk
	     (*)  adjacent  to	the hits information. Cost will	be incremented
	     when the recalculation is done.

       jobs [-p|-l] [%jobid ...]

       jobs -x command [arguments]
	     Reports all jobs that are stopped or executing in the background.
	     If	%jobid is omitted, all jobs that are stopped or	running	in the
	     background	will be	reported. (See Job Control section  below  for
	     more detail.)

       kill [ -sig ] %job ...

       kill -l
	     Sends  either the TERM (terminate)	signal or the specified	signal
	     to	the specified jobs or processes. Signals are either  given  by
	     number  or	 by  names  (as	given in signal(3HEAD) stripped	of the
	     prefix "SIG" with the exception that SIGCHD is  named  CHLD).  If
	     the  signal  being	sent is	TERM (terminate) or HUP	(hangup), then
	     the job or	process	will be	sent a CONT (continue) signal if it is
	     stopped. The argument job can be the process id of	a process that
	     is	not a member of	one of the active jobs.	See Job	 Control  sec-
	     tion  below for a description of the format of job. In the	second
	     form, kill	-l, the	signal numbers	and  names  are	 listed.  (See
	     kill(1)).

       login [ argument	... ]
	     Equivalent	 to  `exec  login argument....'	See login(1) for usage
	     and description.

       newgrp [	argument ]
	     Equivalent	to exec	newgrp argument. See newgrp(1) for  usage  and
	     description.

       pwd   Print  the	 current  working  directory. See pwd(1) for usage and
	     description.

       read name ...
	     One line is read from the standard	input and, using the  internal
	     field  separator,	IFS  (normally	space or tab), to delimit word
	     boundaries, the first word	is assigned to	the  first  name,  the
	     second word to the	second name, and so forth, with	leftover words
	     assigned to the last name.	Lines can be continued using \newline.
	     Characters	 other	than  newline  can be quoted by	preceding them
	     with a backslash. These backslashes are removed before words  are
	     assigned to names,	and no interpretation is done on the character
	     that follows the backslash. The return code is 0, unless  an  EOF
	     is	encountered.

       readonly	[ name ... ]
	     The  given	 names are marked readonly and the values of the these
	     names may not be changed by subsequent assignment.	 If  no	 argu-
	     ments are given, a	list of	all readonly names is printed.

       return [	n ]
	     Causes  a	function to exit with the return value specified by n.
	     If	n is omitted, the return status	is that	of  the	 last  command
	     executed.

       set [ -aefhkntuvx [ argument ...	] ]

	     -a	   Mark	variables which	are modified or	created	for export.

	     -e	   Exit	 immediately  if  a command exits with a non-zero exit
		   status.

	     -f	   Disable file	name generation.

	     -h	   Locate and remember	function  commands  as	functions  are
		   defined  (function  commands	 are normally located when the
		   function is executed).

	     -k	   All keyword arguments are placed in the environment	for  a
		   command, not	just those that	precede	the command name.

	     -n	   Read	commands but do	not execute them.

	     -t	   Exit	after reading and executing one	command.

	     -u	   Treat unset variables as an error when substituting.

	     -v	   Print shell input lines as they are read.

	     -x	   Print commands and their arguments as they are executed.

	     -	   Do  not change any of the flags; useful in setting $1 to -.

	     Using + rather than - causes these	flags to be turned off.	 These
	     flags  can	also be	used upon invocation of	the shell. The current
	     set of flags may be found in  $-.	The  remaining	arguments  are
	     positional	 parameters and	are assigned, in order,	to $1, $2, ...
	     If	no arguments are given,	the values of all names	are printed.

       shift [ n ]
	     The positional parameters from $n+1 ... are renamed $1 ...	. If n
	     is	not given, it is assumed to be 1.

       stop pid	...
	     Halt execution of the process number pid. (see ps(1)).

       suspend
	     Stops  the	 execution  of the current shell (but not if it	is the
	     login shell).

       test  Evaluate conditional  expressions.	 See  test(1)  for  usage  and
	     description.

       times Print  the	 accumulated  user  and	system times for processes run
	     from the shell.

       trap [ argument n [ n2 ... ]]
	     The command argument is to	be read	and executed  when  the	 shell
	     receives  numeric	or  symbolic signal(s) (n). (Note: argument is
	     scanned once when the trap	is set	and  once  when	 the  trap  is
	     taken.)  Trap  commands are executed in order of signal number or
	     corresponding symbolic names. Any attempt to set a	trap on	a sig-
	     nal  that	was  ignored on	entry to the current shell is ineffec-
	     tive. An attempt to trap on signal	11 (memory fault) produces  an
	     error.  If	 argument  is absent, all trap(s) n are	reset to their
	     original values. If argument is the null string, this  signal  is
	     ignored  by  the shell and	by the commands	it invokes. If n is 0,
	     the command argument is executed on exit from the shell. The trap
	     command  with  no	arguments prints a list	of commands associated
	     with each signal number.

       type [ name ... ]
	     For each name, indicate how it would be interpreted if used as  a
	     command name.

       ulimit [	[-HS] [-a | -cdfnstv] ]

       ulimit [	[-HS] [-c | -d | -f | -n | -s |	-t | -v] ] limit
	     ulimit  prints or sets hard or soft resource limits. These	limits
	     are described in getrlimit(2).

	     If	limit is not present, ulimit prints the	specified limits.  Any
	     number of limits may be printed at	one time. The -a option	prints
	     all limits.

	     If	limit is present, ulimit sets the specified  limit  to	limit.
	     The string	unlimited requests the largest valid limit. Limits may
	     be	set for	only one resource at a time. Any user may set  a  soft
	     limit  to	any  value  below the hard limit. Any user may lower a
	     hard limit. Only a	 super-user  may  raise	 a  hard  limit.  (See
	     su(1M).)

	     The  -H  option specifies a hard limit. The -S option specifies a
	     soft limit. If neither option is specified, ulimit	will set  both
	     limits and	print the soft limit.

	     The following options specify the resource	whose limits are to be
	     printed or	set. If	no option is specified,	the file size limit is
	     printed or	set.

	     -c	   maximum core	file size (in 512-byte blocks)

	     -d	   maximum size	of data	segment	or heap	(in kbytes)

	     -f	   maximum file	size (in 512-byte blocks)

	     -n	   maximum file	descriptor plus	1

	     -s	   maximum size	of stack segment (in kbytes)

	     -t	   maximum CPU time (in	seconds)

	     -v	   maximum size	of virtual memory (in kbytes)

       Run  the	 sysdef(1M)  command to	obtain the maximum possible limits for
       your system.  The values	reported are in	hexadecimal, but can be	trans-
       lated into decimal numbers using	the bc(1) utility.  See	swap(1M).)

	     As	an example of ulimit, to limit the size	of a core file dump to
	     0 Megabytes, type the following:

	     ulimit -c 0

       umask [ nnn ]
	     The user file-creation mask is set	to nnn (see umask(1)). If  nnn
	     is	omitted, the current value of the mask is printed.

       unset [ name ...	]
	     For  each	name,  remove  the  corresponding variable or function
	     value. The	variables PATH,	PS1, PS2, MAILCHECK, and IFS cannot be
	     unset.

       wait [ n	]
	     Wait for your background process whose process id is n and	report
	     its termination status. If	n is omitted, all  your	 shell's  cur-
	     rently  active background processes are waited for	and the	return
	     code will be zero.

   Invocation
       If the shell is invoked through exec(2)	and  the  first	 character  of
       argument	 zero  is -, commands are initially read from /etc/profile and
       from $HOME/.profile, if such files exist. Thereafter, commands are read
       as described below, which is also the case when the shell is invoked as
       /usr/bin/sh. The	flags below are	interpreted by the shell on invocation
       only.  Note:  Unless the	-c or -s flag is specified, the	first argument
       is assumed to be	the name  of  a	 file  containing  commands,  and  the
       remaining arguments are passed as positional parameters to that command
       file:

       -c string
	     If	the -c flag is present commands	are read from string.

       -i    If	the -i flag is present or if the shell input  and  output  are
	     attached  to a terminal, this shell is interactive. In this case,
	     TERMINATE is ignored (so that kill	0 does not kill	an interactive
	     shell)  and  INTERRUPT  is	 caught	 and  ignored (so that wait is
	     interruptible). In	all cases, QUIT	is ignored by the shell.

       -p    If	the -p flag is present,	the shell will not set	the  effective
	     user and group IDs	to the real user and group IDs.

       -r    If	 the  -r  flag is present the shell is a restricted shell (see
	     rsh(1M)).

       -s    If	the -s flag is present or if no	arguments remain, commands are
	     read from the standard input. Any remaining arguments specify the
	     positional	parameters. Shell output (except for Special Commands)
	     is	written	to file	descriptor 2.

       The  remaining  flags and arguments are described under the set command
       above.

   Job Control (jsh)
       When the	shell is invoked as jsh, Job Control is	enabled	in addition to
       all  of	the  functionality described previously	for sh.	Typically, Job
       Control is enabled for  the  interactive	 shell	only.  Non-interactive
       shells  typically  do  not  benefit from	the added functionality	of Job
       Control.

       With Job	Control	enabled, every command or pipeline the user enters  at
       the  terminal  is  called a job.	All jobs exist in one of the following
       states: foreground, background, or stopped. These terms are defined  as
       follows:

       1. A job	in the foreground has read and write access to the controlling
	  terminal.

       2. A job	in the background is denied read access	 and  has  conditional
	  write	access to the controlling terminal (see	stty(1)).

       3. A  stopped  job  is a	job that has been placed in a suspended	state,
	  usually as a result of a SIGTSTP signal (see signal(3HEAD)).

       Every job that the shell	starts is assigned a positive integer,	called
       a job number which is tracked by	the shell and will be used as an iden-
       tifier to indicate a specific job. Additionally,	the shell keeps	 track
       of  the	current	 and previous jobs. The	current	job is the most	recent
       job to be started or restarted. The previous job	is the first  non-cur-
       rent job.

       The acceptable syntax for a Job Identifier is of	the form:

       %jobid

       where jobid may be specified in any of the following formats:

       % or +
	     For the current job.

       -     For the previous job.

       ?_string_
	     Specify  the  job	for  which  the	command	line uniquely contains
	     string.

       n     For job number n.

       pref  Where pref	is a unique prefix of the command name.	 For  example,
	     if	 the  command  ls  -l  name were running in the	background, it
	     could be referred to as %ls. pref cannot contain blanks unless it
	     is	quoted.

       When  Job  Control  is enabled, the following commands are added	to the
       user's environment to manipulate	jobs:

       bg [%jobid ...]
	     Resumes the execution of a	stopped	 job  in  the  background.  If
	     %jobid is omitted the current job is assumed.

       fg [%jobid ...]
	     Resumes  the  execution  of a stopped job in the foreground, also
	     moves an executing	background job into the	foreground. If	%jobid
	     is	omitted	the current job	is assumed.

       jobs [-p|-l] [%jobid ...]

       jobs -x command [arguments]
	     Reports all jobs that are stopped or executing in the background.
	     If	%jobid is omitted, all jobs that are stopped or	running	in the
	     background	 will  be  reported.   The following options will mod-
	     ify/enhance the output of jobs:

	     -l	   Report the process group ID and working  directory  of  the
		   jobs.

	     -p	   Report only the process group ID of the jobs.

	     -x	   Replace  any	 jobid	found in command or arguments with the
		   corresponding process group ID, and	then  execute  command
		   passing it arguments.

       kill [ -signal ]	%jobid
	     Builtin  version of kill to provide the functionality of the kill
	     command for processes identified with a jobid.

       stop %jobid ...
	     Stops the execution of a background job(s).

       suspend
	     Stops the execution of the	current	shell (but not if  it  is  the
	     login shell).

       wait [%jobid ...]
	     wait  builtin accepts a job identifier. If	%jobid is omitted wait
	     behaves as	described above	under Special Commands.

   Large File Behavior
       See largefile(5)	for the	description of the behavior of sh and jsh when
       encountering files greater than or equal	to 2 Gbyte ( 2**31 bytes).

EXIT STATUS
       Errors detected by the shell, such as syntax errors, cause the shell to
       return a	non-zero exit status. If the shell is being used  non-interac-
       tively  execution  of the shell file is abandoned. Otherwise, the shell
       returns the exit	status of the last command executed (see also the exit
       command above).

   jsh Only
       If the shell is invoked as jsh and an attempt is	made to	exit the shell
       while there are stopped jobs, the shell issues one warning:

       There are stopped jobs.

       This is the only	message. If another exit attempt is  made,  and	 there
       are  still stopped jobs they will be sent a SIGHUP signal from the ker-
       nel and the shell is exited.

FILES
       $HOME/.profile

       /dev/null

       /etc/profile

       /tmp/sh*

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

   /usr/bin/sh
   /usr/bin/jsh
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+

   /usr/xpg4/bin/sh
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWxcu4			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+

SEE ALSO
       intro(1), bc(1),	echo(1), getoptcvt(1), kill(1),	ksh(1),	login(1), new-
       grp(1),	ps(1),	pwd(1),	 set(1),  shell_builtins(1), stty(1), test(1),
       umask(1),  wait(1),  rsh(1M),  su(1M),  swap(1M),  sysdef(1M),  dup(2),
       exec(2),	fork(2), getrlimit(2), pipe(2),	ulimit(2), setlocale(3C), sig-
       nal(3HEAD), passwd(4), profile(4),  attributes(5),  environ(5),	large-
       file(5),	XPG4(5)

WARNINGS
       The use of setuid shell scripts is strongly discouraged.

NOTES
       Words  used  for	 filenames  in input/output redirection	are not	inter-
       preted for  filename  generation	 (see  File  Name  Generation  section
       above). For example, cat	file1 >a* will create a	file named a*.

       Because	commands in pipelines are run as separate processes, variables
       set in a	pipeline have no effect	on the parent shell.

       If you get the error message, "cannot  fork,too	many  processes",  try
       using  the  wait(1)  command  to	clean up your background processes. If
       this doesn't help, the system process table is  probably	 full  or  you
       have too	many active foreground processes. There	is a limit to the num-
       ber of process ids associated with your login, and to  the  number  the
       system can keep track of.

       Only the	last process in	a pipeline can be waited for.

       If a command is executed, and a command with the	same name is installed
       in a directory in the search path before	the directory where the	origi-
       nal  command  was  found,  the shell will continue to exec the original
       command.	Use the	hash command to	correct	this situation.

       The Bourne shell	has a limitation on the	effective UID for  a  process.
       If  this	 UID  is  less	than 100 (and not equal	to the real UID	of the
       process), then the UID is reset to the real UID of the process.

       Because the shell implements both foreground and	background jobs	in the
       same  process  group, they all receive the same signals,	which can lead
       to unexpected behavior. It is, therefore, recommended  that  other  job
       control shells be used, especially in an	interactive environment.

       When  the shell executes	a shell	script that attempts to	execute	a non-
       existent	command	interpreter, the shell returns an erroneous diagnostic
       message that the	shell script file does not exist.

SunOS 5.9			  18 Oct 2001				 sh(1)

NAME | SYNOPSIS | DESCRIPTION | USAGE | EXIT STATUS | FILES | ATTRIBUTES | SEE ALSO | WARNINGS | NOTES

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=sh&sektion=1&manpath=SunOS+5.9>

home | help