Linux Kernel and Commands

General Midterm Information

• This midterm is comprehensive.
• Familiarize yourself with all concepts.
• Review labs and codes from class; there will be nothing from zybooks.
• Code understanding will be tested, but coding will not be required.
• The exam includes theoretical and practical questions.
• There will be approximately 30 multiple-choice and 5 open-ended questions.

Lecture 1: The Kernel and Linux Commands

• The kernel is like the brain of the computer system, performing core functions.
• Kernel functions include acting as a medium between hardware and software.
• Memory management is a kernel function.
• Process management is a kernel function.
• Input/output and file system management are kernel functions.
• The file system is represented as a tree.
• The root of the file system is represented by "/".
• The filesystem organizes and accesses files.
• Common Linux commands include:
• ls: list directory contents
• cd: change directory
• mkdir: make directory
• mv: move files or directories
• cp: copy files or directories
• scp: secure copy (remote file copy)
• tar: archive files
• rm: remove files or directories
• chmod: change file permissions
• cat: concatenate and display files
• grep: search for a pattern in files
• less: view file contents page by page
• more: view file contents page by page
• man: display manual pages for commands
• sudo stands for "Super User Do"
• sudo allows running commands with elevated privileges.
• gcc is a built-in compiler and part of the GNU Compiler Collection
• gcc compiles source code into machine code.
• To compile code use: gcc -o <output_file name> <source_file.c>
• -o specifies the output file name when compiling with gcc.

Lecture 2: Memory Organization

• A program sees memory as an array of bytes, ranging from 0 to 2^64 - 1.
• Memory is organized into memory mappings
• The TEXT section stores instructions that the program runs.
• The DATA section stores initialized global variables.
• The BSS section stores uninitialized global variables, which are initialized to zeros until a value is assigned.
• The HEAP stores memory returned by malloc/new.
• The STACK stores local variables and return addresses.
• Shared libraries (.so files) are not added to the executable file and are dynamically loaded at runtime
• Shared libraries consist of definitions only, so they do not increase the executable file size.
• The heap is space for dynamic memory allocation and grows upward.
• The stack grows downwards and stores local variables.
• Each program has an independent view of memory.
• Gaps between memory sections may lack memory mapping.
• Accessing a memory gap results in a SEGV signal, which typically terminates the program and creates a core file.
• Static libraries are not shared and have an instance for each process; they are represented as (.a) files added to the executable.
• Shared libraries are shared across different processes with only one instance for the entire system.
• Static events happen during program building.
• Dynamic events happen while a program is running.
• Variable types in C programming include int, char, double, pointer, string, float, short, long, and unsigned.

Lecture 3: Operators, and Preprocessor Directives

• With integer overflow, C uses two's complement and wraps back to the beginning of the value range.
• Inputting 2,147,483,648 results to an output of -2,147,483,648 due to integer overflow.
• printf() prints variables and expressions to standard output (the terminal).
• scanf() takes input from standard input (the console).
• The "&" operator is the address of operator.
• When paired with a variable, "&" is used to acquire the memory address.
• "%" (percent sign) is the format specifier for printing and scanning.
• #include is a preprocessor directive that declares libraries or files for use in the code.
• #define is a preprocessor directive and creates macros: constant values or expressions that the preprocessor substitutes before compilation.

Lecture 4: Ternary Operations

• Ternary operations use the '?' and ':' symbols.
• ? can be considered as 'then', and : can be considered as 'otherwise'.
• Ternary expressions can be read as:
• variable = (condition) ? Expression2 : Expression3;
• (condition) ? (Expression2) : (Expression3);
• variable = Expression1 ? Expression2 : Expression3;

Lecture 5: Functions

• Functions perform specific tasks when called and contains
  • Declaration
  • Definition
  • Function call
• A function prototype is a declaration that tells the compiler about a function's existence and signature (return type, name, parameters).
• Prototypes prevent implicit declaration warnings, which occurs when a function is called before its definition without the compiler knowing its structure.
• Passing arguments by value results copies the values into function parameters; changing the parameters does not modify the original values.
• Passing by reference allows the function to operate on the original data, allowing modification of the original variable, and avoiding copying large data structures.
• Recursion is a technique where a function calls itself to solve smaller subproblems.

Lecture 6: Pointers

• A pointer is a variable that stores a memory address.
• A pointer uses 8 bytes in a 64-bit system and 4 bytes in a 32-bit system, regardless of the data type it points to.
• An integer uses 4 bytes and a character uses 1 byte in a 64-bit system.
• "*" is the dereference operator and is used to access the data stored at a memory address.
• Pointers store a memory address.
• int *ptr = &var; means *ptr = &var will point at the memory address of &var.
• ptr alone will produce the memory address of var.
• *ptr will produce the value that resides at that memory address.
• (*ptr)++ dereferences and adds 1 to the value. *ptr++ increments the pointer to the next memory address.
• Unary operators read from right to left.
• A double pointer stores the memory address of another pointer.
• Double pointers are useful for managing dynamically allocated memory as well as dealing with complex data structures.
• int var = 10; int *ptr = &var; int **dptr = &ptr; initializes var to 10, ptr to the memory address of var, and dptr to the memory address of ptr.
• Dereferencing dptr twice accesses the contents of var.
• When passing an array to a function, or any part thereof, array decay occurs; the array name decays into a pointer to the first element, we are passing the memory address and need to know the size.

Lecture 7: Arrays and the Stack

• sizeof() returns the total bytes of what is in the parentheses.
• sizeof() is used to determine the size of the array to get the actual array size by doing sizeof(array)/sizeof(array[0]).
• When passing an array to a function, the memory address of the first element is the parameter.
• When passing an array, it then becomes a pointer.
• Iteration of an array using pointer arithmetic can be done by adding a value to a base pointer to move positions in memory.
• The expression *(ptr + 2) produces the value at the index.
• The stack stores information for passing control and data and allocating memory, including:
• Function local variables
• Temporary variables
• Arguments for the next function call
• The return address, when the function ends.
• Push is used to add data and Pop is used to remove data from the stack.
• The compiler manages the stack by:
• Creating one stack frame each time a function is called.
• Stack frames are created when the function is called.
• Frames are stacked on top of one another.
• Frames are destroyed at function exit.
• Errors that can occur in the stack:
• Running out of stack space
• Unintentionally changing values on the stack (in other function frames or return addresses)
• Accessing memory, even after the frame is deallocated
• Stack overflow occurs when the stack space runs out.
• Buffer overflow occurs when more data than anticipated gets placed by a program or system process to the stack, overflowing the stack
• Pointers are more efficient for array indexing because the normal indexing requires multiplication to find the correct index.

Lecture 8: Malloc and Memory

• malloc dynamically allocates a single large block of memory with a specified size.
• malloc returns a pointer to a block of memory and stores the memory allocated by malloc is stored in the heap
• The reason for a pointer cast type is because the malloc function returns a pointer to void.
• The size of a pointer in a 32-bit system is 4 bytes.

Lecture 9/10: Memory Allocation

• Ways of indexing:
• Assuming int a[20] is defined:
• A[i] is equivalent to *(a+i) and *(&a[0]+i)
• Memory previously allocated by malloc or calloc is deallocated by free. Doing so prevents memory leaks.
• Memory leaks are objects in memory that are no longer in use by the program but that are not freed.
• Not deallocating memory leads to memory leaks.
• The heap can run out of space, in which case malloc will return 0.
• One can unintentionally change other heap data, or clobber heap data by overwriting a register during execution.
• Other heap errors are Accessing memory after it has been freed or freeing memory twice, which could cause crashing or corruption.
• Such heap errors create a memory leak.

Lecture 11: Memory Management Errors

• A premature free is caused when an object still used by the program is freed.
• A double free is caused by freeing an object that is already free.
• Wild frees happen when a program attempts to free a pointer in memory that was not returned by malloc.
• Memory smashing occurs when less memory is allocated than will be used.
• Memory fragmentation occurs when aggregation of memory lacks a single large block.