Operating Systems 2014F: Assignment 2 - Revision history

Soma: /* Solutions */

2014-09-25T19:19:19Z

Solutions

← Older revision		Revision as of 19:19, 25 September 2014
Line 26:		Line 26:
	===zero.c===		===zero.c===
	<source lang="c">		<source lang="c">
	~~/* zero.c */~~

	#include <stdio.h>		#include <stdio.h>

Line 39:		Line 37:
	===limitedbomb.c===		===limitedbomb.c===
	<source lang="c">		<source lang="c">
	~~/* limitedbomb.c */~~

	#include <stdio.h>		#include <stdio.h>
	#include <stdlib.h>		#include <stdlib.h>

Soma: /* Solutions */

2014-09-25T19:19:00Z

Solutions

← Older revision		Revision as of 19:19, 25 September 2014
Line 21:		Line 21:
	# Environment variables are not global variables, they are process-specific and stored in the process's address space. Thus changes to a process's environment variables only affect it and its subsequent children (as produced by fork). Environment variables may or may not be passed on when a new program is run via execve (environment variables are one of the arguments to this system call).		# Environment variables are not global variables, they are process-specific and stored in the process's address space. Thus changes to a process's environment variables only affect it and its subsequent children (as produced by fork). Environment variables may or may not be passed on when a new program is run via execve (environment variables are one of the arguments to this system call).
	# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".		# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".
	# ~~Here~~ is a ~~simple program~~ that ~~accesses address 0:~~		# See zero.c below. When run on the command line this program outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.
			# See limitedbomb.c below.

			===zero.c===
	<source lang="c">		<source lang="c">
			/* zero.c */

	#include <stdio.h>		#include <stdio.h>

Line 31:		Line 36:
	}		}
	</source>		</source>
	When run on the command line this outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.
	#		===limitedbomb.c===
	<source lang="c">		<source lang="c">
	/* limitedbomb.c */		/* limitedbomb.c */

Soma: /* Solutions */

2014-09-25T19:16:58Z

Solutions

← Older revision		Revision as of 19:16, 25 September 2014
Line 22:		Line 22:
	# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".		# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".
	# Here is a simple program that accesses address 0:		# Here is a simple program that accesses address 0:
	<source ~~language~~="C">		<source lang="c">
	#include <stdio.h>		#include <stdio.h>

Line 33:		Line 33:
	When run on the command line this outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.		When run on the command line this outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.
	#		#
	<source ~~language~~="C">		<source lang="c">
	/* limitedbomb.c */		/* limitedbomb.c */

Soma: /* Solutions */

2014-09-25T19:16:40Z

Solutions

← Older revision		Revision as of 19:16, 25 September 2014
Line 22:		Line 22:
	# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".		# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".
	# Here is a simple program that accesses address 0:		# Here is a simple program that accesses address 0:
	<source language="c">		<source language="C">
	#include <stdio.h>		#include <stdio.h>

Line 33:		Line 33:
	When run on the command line this outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.		When run on the command line this outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.
	#		#
	<source language="c">		<source language="C">
	/* limitedbomb.c */		/* limitedbomb.c */

Soma at 19:16, 25 September 2014

2014-09-25T19:16:25Z

← Older revision		Revision as of 19:16, 25 September 2014
Line 14:		Line 14:
	# [2] What happens when a program attempts to access memory location 0? Give a simple program that attempts to do this and explain what happens when it runs. Be sure to explain what program produces the output seen at the command line. (You may want to run the program using <tt>strace</tt> to get a better idea what is happening.)		# [2] What happens when a program attempts to access memory location 0? Give a simple program that attempts to do this and explain what happens when it runs. Be sure to explain what program produces the output seen at the command line. (You may want to run the program using <tt>strace</tt> to get a better idea what is happening.)
	# [2] Give the code for a limited "fork bomb" that creates the number of processes listed on the command line. Each process should print out which process it is, e.g. "I am bomb process 17!" (where the count is the count of the number of processes created, not the PID). After printing the count each should then sleep for 30 seconds (using [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sleep.html sleep()]) and then terminate.		# [2] Give the code for a limited "fork bomb" that creates the number of processes listed on the command line. Each process should print out which process it is, e.g. "I am bomb process 17!" (where the count is the count of the number of processes created, not the PID). After printing the count each should then sleep for 30 seconds (using [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sleep.html sleep()]) and then terminate.

			==Solutions==

			# System calls are how regular processes invoke code in the kernel while function calls are how code is invoked inside of a regular process. Functions and system calls both take arguments that are pushed onto the stack. Functions are invoked by pushing the current program counter address onto the stack and jumping to the address of the function's code (e.g., using a CALL x86 instruction). System calls make a trap/software interrupt (e.g., INT 0x80 or SYSCALL/SYSENTER on x86) that causes the CPU to switch modes to supervisor mode, run a dispatcher, make a function call within the kernel, then return back to userspace (running the same or another process, depending upon the scheduler). Note that regular programs don't make system calls directly; instead they call standard function which in turn make system calls using inline assembly or C extensions.
			# From the command line use "kill -SIGSTOP <PID>" to stop and "kill -SIGCONT <PID>" to continue. From C, use kill() in a similar fashion.
			# Environment variables are not global variables, they are process-specific and stored in the process's address space. Thus changes to a process's environment variables only affect it and its subsequent children (as produced by fork). Environment variables may or may not be passed on when a new program is run via execve (environment variables are one of the arguments to this system call).
			# The argument declaration in C is "char *const envp[]". envp is an array of pointers to environment variables. The final element in this array must be NULL. Each of the other elements points to a null-terminated string in the form of "name=value".
			# Here is a simple program that accesses address 0:
			<source language="c">
			#include <stdio.h>

			int main(int argc, char *argv[])
			{
			printf("The value of zero as a byte: %d\n", ((int ) 0));
			return 0;
			}
			</source>
			When run on the command line this outputs something like "segmentation fault (core dumped)". The printf() does not run because the access to address 0 happens as part of assembling its arguments (it is never called). This happens because the kernel generated a SIGSEGV signal because the process was accessing a part of its address space that wasn't allocated/valid.
			#
			<source language="c">
			/* limitedbomb.c */

			#include <stdio.h>
			#include <stdlib.h>
			#include <sys/types.h>
			#include <sys/wait.h>

			int main(int argc, char *argv[]) {
			int count, i, status;
			pid_t pid;

			if (argc < 2) {
			fprintf(stderr, "Usage: %s <num processes to create>\n",
			argv[0]);
			return -1;
			}

			count = atoi(argv[1]);

			for (i = 1; i <= count; i++) {
			pid = fork();

			if (pid==0) {
			printf("I am bomb process %d!\n", i);
			sleep(30);
			return i;
			}
			}

			for (i = 0; i < count; i++) {
			pid = wait(&status);

			printf("Child %d returned.\n",WEXITSTATUS(status));
			}

			return 0;
			}
			</source>

Soma at 20:09, 12 September 2014

2014-09-12T20:09:34Z

← Older revision		Revision as of 20:09, 12 September 2014
Line 1:		Line 1:
	~~'''This assignment is not yet finalized.'''~~

	Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There 10 points in 6 questions.		Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There 10 points in 6 questions.

Soma: /* Questions */

2014-09-12T18:42:44Z

Questions

← Older revision		Revision as of 18:42, 12 September 2014
Line 13:		Line 13:
	# [1] How would you send a signal to a process to have it pause execution? Resume?		# [1] How would you send a signal to a process to have it pause execution? Resume?
	# [2] Where are environment variables stored? Specifically, if a process changes its environment variables, are the variables of any other processes changed? Be sure to consider currently running and processes created in the future.		# [2] Where are environment variables stored? Specifically, if a process changes its environment variables, are the variables of any other processes changed? Be sure to consider currently running and processes created in the future.
	# [2] Give the code for a limited "fork bomb" that creates the number of processes listed on the command line. Each process should print out which process it is, e.g. "I am bomb process 17!" (where the count is the count of the number of processes created, not the PID). After printing the count each should then sleep for 30 seconds (using [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sleep.html sleep()]) and then terminate.
	# [2] Precisely describe the data structure used to store environment variables when they are passed to <tt>execve()</tt>.		# [2] Precisely describe the data structure used to store environment variables when they are passed to <tt>execve()</tt>.
	# [2] What happens when a program attempts to access memory location 0? Give a simple program that attempts to do this and explain what happens when it runs. Be sure to explain what program produces the output seen at the command line. (You may want to run the program using <tt>strace</tt> to get a better idea what is happening.)		# [2] What happens when a program attempts to access memory location 0? Give a simple program that attempts to do this and explain what happens when it runs. Be sure to explain what program produces the output seen at the command line. (You may want to run the program using <tt>strace</tt> to get a better idea what is happening.)
			# [2] Give the code for a limited "fork bomb" that creates the number of processes listed on the command line. Each process should print out which process it is, e.g. "I am bomb process 17!" (where the count is the count of the number of processes created, not the PID). After printing the count each should then sleep for 30 seconds (using [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sleep.html sleep()]) and then terminate.

Soma at 18:41, 12 September 2014

2014-09-12T18:41:53Z

← Older revision		Revision as of 18:41, 12 September 2014
Line 1:		Line 1:
	'''This assignment is not yet finalized.'''		'''This assignment is not yet finalized.'''

	Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There ?? points in ?? questions.		Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There 10 points in 6 questions.

	Submit your answers as a single text file named "<username>-comp3000-assign2.txt" (where username is your MyCarletonOne username). The first four lines of this file should be "COMP 3000 Assignment 2", your name, student number, and the date of submission. You may wish to format your answers in [http://en.wikipedia.org/wiki/Markdown Markdown] to improve their appearance.		Submit your answers as a single text file named "<username>-comp3000-assign2.txt" (where username is your MyCarletonOne username). The first four lines of this file should be "COMP 3000 Assignment 2", your name, student number, and the date of submission. You may wish to format your answers in [http://en.wikipedia.org/wiki/Markdown Markdown] to improve their appearance.

Soma: Created page with "'''This assignment is not yet finalized.''' Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There ?? points in..."

2014-09-12T18:41:37Z

Created page with "'''This assignment is not yet finalized.''' Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There ?? points in..."

New page

'''This assignment is not yet finalized.'''

Please submit the answers to the following questions via CULearn by midnight on Wednesday, September 17, 2014. There ?? points in ?? questions.

Submit your answers as a single text file named "<username>-comp3000-assign2.txt" (where username is your MyCarletonOne username). The first four lines of this file should be "COMP 3000 Assignment 2", your name, student number, and the date of submission. You may wish to format your answers in [http://en.wikipedia.org/wiki/Markdown Markdown] to improve their appearance.

'''No other formats will be accepted.''' Submitting in another format will likely result in your assignment not being graded and you receiving no marks for this assignment. In particular do not submit an MS Word or OpenOffice file as your answers document!

Don't forget to include what outside resources you used to complete each of your answers, including other students, man pages, and web resources. You do not need to list help from the instructor, TA, or information found in the textbook.

==Questions==
# [1] What is the relationship between function calls and system calls?
# [1] How would you send a signal to a process to have it pause execution? Resume?
# [2] Where are environment variables stored? Specifically, if a process changes its environment variables, are the variables of any other processes changed? Be sure to consider currently running and processes created in the future.
# [2] Give the code for a limited "fork bomb" that creates the number of processes listed on the command line. Each process should print out which process it is, e.g. "I am bomb process 17!" (where the count is the count of the number of processes created, not the PID). After printing the count each should then sleep for 30 seconds (using [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sleep.html sleep()]) and then terminate.
# [2] Precisely describe the data structure used to store environment variables when they are passed to <tt>execve()</tt>.
# [2] What happens when a program attempts to access memory location 0? Give a simple program that attempts to do this and explain what happens when it runs. Be sure to explain what program produces the output seen at the command line. (You may want to run the program using <tt>strace</tt> to get a better idea what is happening.)