CS 211
Programming Assignment 3
Assigned: Wed, Mar 5
Due: Wed, March 26 @ 11:59 pm (3 weeks)
This handout is structured similarly to PA1 and PA2: This page gives a top-level overview of the assignment, and the Document Tabs provide details on each part.
Introduction
You will simulate a Linux-like filesystem, complete with operations such as rm, mkdir, touch, and chmod. Files and directories will be represented as nodes in a tree data structure, with each node holding file/directory names and permissions.
In this assignment, you will need to deserialize the filesystem from a binary representation, whose specification we will provide. After deserializing the filesystem, you will implement the functions that perform. file and directory operations. You will need to check for and implement different error cases that are possible (e.g., rm on a read-only file).
Concepts that we recommend reviewing for this assignment include:
● Pointers and pointer manipulation
● Arrays and structs
● Bitwise operations and masking
● Dynamic memory management (malloc, free)
As usual, concepts from this programming assignment (as with all others) are fair game for the midterm and final exam.
PA3 is divided into two parts:
Part 1: Deserialization
You will first reconstruct the filesystem’s tree data structure from a binary file that contains a serialized representation of the tree. The Document Tab for “Serialized Encoding” describes the exact encoding format.
Part 2: Implementing Filesystem Operations
Once the filesystem tree is constructed, you will implement several functions that perform. operations on the filesystem. The details of the functions you need to implement are provided in both:
1. This document under the Document Tab “Functions to Write”
2. The header file src/pa3.h
Setup
Accept the GitHub Classroom PA3 invitation (below) and clone your repository on ilab (follow instructions from PA1). We will assume you’ve cloned the repository to the path ~/cs211/pa3 for the rest of the handout.
Invitation URLs
● GitHub Classroom PA3 invitation
⚠ BUG FIXES
Please manually fix the following minor function naming mishaps once you clone your repository:
src/pa3.c:21 print_node_data -> pa3_print_node_data
src/pa3_test.c:88 print_tree -> pa3_print_tree
Final Deliverables
You will submit your C code on Gradescope via your GitHub repository, just like you did for PA1 and PA2.
Grading
Assignment breakdown out of 100 points:
● [5 points] Your submitted code compiles
● [95 points] Your implemented functions work correctly on the provided filesystems
|
Points
|
Function
|
|
20
|
pa3_deserialize_node
|
|
8
|
pa3_free_tree
|
|
18
|
pa3_rm
|
|
9
|
pa3_touch
|
|
9
|
pa3_mkdir
|
|
8
|
extract_node_name
|
|
15
|
pa3_navigate_to_node
|
|
8
|
pa3_chmod_impl
|
You will be graded based on:
● Freeing all of the memory that you dynamically allocate.
● Allocating no more memory to store any given object than strictly necessary (e.g., do not allocate large structures and use only part of them).
● Correct handling of error cases (e.g., attempting to mkdir in a location with read-only permissions).
Once our Gradescope submission assignment is up, you may submit. Like PA2, you have unlimited submissions and will see your score after each submission.
We expect you to follow the spirit of the assignment, which is to exercise good dynamic memory management practices.
We may give you a 0 if we see that you short-cut the concepts in the assignment (e.g., hard-code the output, over-allocate memory). If you are unsure whether you are in violation, please ask the staff privately through Ed.
Testing Your Code
We have provided you with:
● filesystems/fs*.bin: All of the serialized filesystems that we will grade your code with. There will be no extra hidden filesystems. The filesystems/fs*.txt files display what each filesystem binary contains. If you correctly deserialize a filesystem, you should expect the output of pa3_print_tree to match the corresponding *.txt file
● src/pa3_test.c/h: A C-based testing harness where you can call different functions to check that they work properly. fs0_test serves as an example for running operations on the filesystem filesystems/fs0_root_only_rw.bin.
We expect you to modify src/main.c and src/pa3_test.c to implement your own tests for the provided filesystems. You may call any of the pa3_* functions, using the provided fs0_test as an example for writing your own.
See the Document Tab on “Testing Your Code” for more detail.
Debugging Your Code
We highly recommend using make sanitize and make valgrind to check your code for dynamic memory management problems, in addition to your favorite methods from PA2, e.g., print statements (e.g., pa3_print_tree), GDB, and comparing expected values against observed ones.
See the Document Tab on “Debugging Your Code” for more details.