User heap f

inc/environment_definitions.h

@@ -108,7 +108,9 @@ struct Env {
 	int priority;					// Current priority
 	char prog_name[PROGNAMELEN];	// Program name (to print it via USER.cprintf in multitasking)
 	void* channel;					// Address of the channel that it's blocked (sleep) on it
-
+	// used in free env
+	    uint32** startVAs;
+	    int shared_object_no;
 	//================
 	/*ADDRESS SPACE*/
 	//================

inc/x86.h

@@ -48,6 +48,10 @@ static __inline void write_esp(uint32 esp) __attribute__((always_inline));
 static __inline void write_ebp(uint32 ebp) __attribute__((always_inline));
 static __inline void cpuid(uint32 info, uint32 *eaxp, uint32 *ebxp, uint32 *ecxp, uint32 *edxp);
 static __inline uint64 read_tsc(void) __attribute__((always_inline));
+static inline __attribute__((always_inline)) struct uint64 get_virtual_time_user();
+
+
+#define RANDU(s,e)	((get_virtual_time_user().low % (e-s) + s))
 
 static __inline void
 breakpoint(void)
@@ -366,4 +370,16 @@ static __inline void lidt(struct Gatedesc *p, int size)
 
   asm volatile("lidt (%0)" : : "r" (pd));
 }
+
+
+static inline __attribute__((always_inline)) struct uint64 get_virtual_time_user()
+{
+	struct uint64 result;
+
+	__asm __volatile("rdtsc\n"
+	: "=a" (result.low), "=d" (result.hi)
+	);
+
+	return result;
+}
 #endif /* !FOS_INC_X86_H */

kern/cmd/command_prompt.c

@@ -263,10 +263,11 @@ void run_command_prompt()
 {
 	if (autograde)
 	{
-		char cmd1_2[BUFLEN] = "tst bsd_nice 0";
-		char cmd2_2[BUFLEN] = "tst bsd_nice 1";
-		char cmd3_2[BUFLEN] = "tst bsd_nice 2";
-		//execute_command(cmd3_2);
+		char cmdU1_2[BUFLEN] = "tst priorityRR 0";	//
+		char cmdU2_2[BUFLEN] = "tst priorityRR 1";	//
+		char cmdU3_2[BUFLEN] = "tst priorityRR 2";	//
+
+//		execute_command(cmdU3_2);
 		autograde = 0;
 	}
 	/*2024*/
@@ -453,47 +454,16 @@ int execute_command(char *command_string)
 }
 
 
-int subsequence_matched(char *command_name, char *arg_name){
-	int ptr_command_name=0,ptr_arg_name=0;
-	int len_command_name=strlen(command_name);
-	int len_arg_name=strlen(arg_name);
-
-	while(ptr_command_name<len_command_name && ptr_arg_name<len_arg_name){
-		if(arg_name[ptr_arg_name]==command_name[ptr_command_name]){
-			ptr_command_name++;
-			ptr_arg_name++;
-		}else ptr_command_name++;
-	}
-
-	if(ptr_arg_name>=len_arg_name)
-		return 1;
-	else return 0;
-
-}
-
 int process_command(int number_of_arguments, char** arguments)
 {
 	//TODO: [PROJECT'24.MS1 - #01] [1] PLAY WITH CODE! - process_command
-	LIST_INIT(&foundCommands); // initialize it for the Matched Commands
 
 	for (int i = 0; i < NUM_OF_COMMANDS; i++)
 	{
 		if (strcmp(arguments[0], commands[i].name) == 0)
 		{
-			LIST_INIT(&foundCommands); // empty the list
-
-			if((commands[i].num_of_args==number_of_arguments-1) || (commands[i].num_of_args==-1 && number_of_arguments>1)){
-				return i;
-			}else{
-				LIST_INSERT_TAIL(&foundCommands, &commands[i]); // insert it with one found command
-				return CMD_INV_NUM_ARGS;
-			}
-		}else if(subsequence_matched(commands[i].name,arguments[0])){
-			LIST_INSERT_TAIL(&foundCommands, &commands[i]);
+			return i;
 		}
 	}
-	int size = LIST_SIZE(&foundCommands);
-	if(size<=0)
-		return CMD_INVALID;
-	else return CMD_MATCHED;
+	return CMD_INVALID;
 }

kern/init.c

@@ -81,7 +81,7 @@ void FOS_initialize()
 		initialize_kheap_dynamic_allocator(KERNEL_HEAP_START, PAGE_SIZE, KERNEL_HEAP_START + DYN_ALLOC_MAX_SIZE);
 #endif
 		//	page_check();
-		setPageReplacmentAlgorithmNchanceCLOCK();
+		setPageReplacmentAlgorithmNchanceCLOCK(1);
 		//setPageReplacmentAlgorithmLRU(PG_REP_LRU_TIME_APPROX);
 		//setPageReplacmentAlgorithmFIFO();
 		//setPageReplacmentAlgorithmLRU(PG_REP_LRU_LISTS_APPROX);
@@ -122,8 +122,8 @@ void FOS_initialize()
 		irq_clear_mask(4);
 		cprintf("*	IRQ4 (COM1): is Enabled\n");
 		//Enable Primary ATA Hard Disk Interrupt
-//		irq_clear_mask(14);
-//		cprintf("*	IRQ14 (Primary ATA Hard Disk): is Enabled\n");
+		//		irq_clear_mask(14);
+		//		cprintf("*	IRQ14 (Primary ATA Hard Disk): is Enabled\n");
 	}
 	cprintf("* 5) SCHEDULER & MULTI-TASKING:\n");
 	{
@@ -145,11 +145,105 @@ void FOS_initialize()
 	cprintf("********************************************************************\n");
 
 	// start the kernel command prompt.
-	autograde = 0;
+	autograde = 1;
 	while (1==1)
 	{
 		cprintf("\nWelcome to the FOS kernel command prompt!\n");
 		cprintf("Type 'help' for a list of commands.\n");
+		if (autograde)
+		{
+			/*CHECK THE FOLLOWING:
+			 * 1) time of each test
+			 * 2) "unhandled trap in" message
+			 */
+			cprintf("\nMS3 Automatic testing is STARTED...\n") ;
+
+			//TEST#1: FAULT HANDLER II [NTH CLOCK NORMAL] 	[10 sec]
+			{
+				char cmd0[BUFLEN] = "nclock 5 1";
+				char cmd1[BUFLEN] = "run tpr1 11";
+				char cmd2[BUFLEN] = "run tpr2 6";
+				char cmd3[BUFLEN] = "run tnclock1 11";
+				char cmdU[BUFLEN] = "run tnclock3 11";
+
+//				execute_command(cmd0);
+//				execute_command(cmdU);
+			}
+			//TEST#2: FAULT HANDLER II [NTH CLOCK MODIFIED] [10 sec]
+			{
+				char cmd0[BUFLEN] = "nclock 5 2";
+				char cmd1[BUFLEN] = "run tpr1 11";
+				char cmd2[BUFLEN] = "run tpr2 6";
+				char cmd3[BUFLEN] = "run tnclock2 11";
+
+//				execute_command(cmd0);
+//				execute_command(cmd3);
+			}
+
+			//TEST#3: SEMAPHORES	[30 sec]
+			{
+				char cmd1[BUFLEN] = "run tsem1 500";	//5 sec
+				char cmd2[BUFLEN] = "run tsem2 500";	//20 sec
+				char cmdU[BUFLEN] = "run tair 500";		//10 sec
+//				execute_command(cmd1);
+			}
+
+			//TEST#4: PRIORITY RR SCHEDULER
+			{
+				char cmd01[BUFLEN] = "schedPRIRR 10 40 1000";
+				char cmd03[BUFLEN] = "schedPRIRR 10 40 20";
+//				execute_command(cmd03);
+
+				char cmdU1_1[BUFLEN] = "tst priorityRR 0";	//52 sec
+				char cmdU2_1[BUFLEN] = "tst priorityRR 1";	//58 sec
+				char cmdU3_1[BUFLEN] = "tst priorityRR 2";	//90 sec
+//				execute_command(cmdU3_1);
+			}
+
+			//TEST#4: BONUSES
+			{
+				//[1] EXIT I
+				{
+//					char cmd0_1[BUFLEN] = "fifo";
+//					char cmd1_1[BUFLEN] = "run tef1 5";		//4s
+//					char cmd2_1[BUFLEN] = "run tef2 15";	//20s
+//					//					execute_command(cmd0_1);
+//					//					execute_command(cmd2_1);
+//
+//					char cmd0_2[BUFLEN] = "lru 2";
+//					char cmd1_2[BUFLEN] = "run tef1 5 3";	//6s
+//					char cmd2_2[BUFLEN] = "run tef2 15 5";	//25s
+//					//					execute_command(cmd0_2);
+//					//					execute_command(cmd2_2);
+				}
+				//[2] FREE SHARED OBJECT
+				{
+					char cmd1[BUFLEN] = "run tshr4 3000";
+					char cmd2[BUFLEN] = "run tshr5 3000";
+					//execute_command(cmd1);
+				}
+			}
+			//TEST#5: OVERALL SCENARIOS 	[3min]
+			{
+//				char cmd0_1[BUFLEN] = "fifo";
+//				char cmd0_2[BUFLEN] = "lru 2";
+//				execute_command(cmd0_1);
+//
+//				char cmd1[BUFLEN] = "run sc_MultipleApps 10000";		//45s
+//				char cmd2[BUFLEN] = "run sc_LEAK_NOLEAK 5000";			//55s
+//				char cmd3[BUFLEN] = "run sc_FIFO_LRUList 5000";			//35s
+//				execute_command(cmd1);
+//
+//				char cmd4_1[BUFLEN] = "schedBSD 64 5";
+//				char cmd4_2[BUFLEN] = "run sc_bsd_1 20 20";		//fifo	//1m20s
+//				char cmd5_2[BUFLEN] = "run sc_bsd_1 20 5 20";	//lru	//1m
+//				//				execute_command(cmd4_1);
+//				//				execute_command(cmd5_2);
+
+			}
+			cprintf("MS3 Automatic testing is ENDED\n") ;
+			autograde = 0;
+		}
 		get_into_prompt();
 	}
 }
@@ -272,7 +366,7 @@ void _panic_into_prompt(const char *file, int line, const char *fmt,...)
 	cprintf("\n");
 	va_end(ap);
 
-//	dead:
+	//	dead:
 	/* break into the fos scheduler */
 	//2013: Check if the panic occur when running an environment
 	struct Env* cur_env = get_cpu_proc();

kern/mem/kheap.c

@@ -113,7 +113,7 @@ void *sbrk(int numOfPages)
 			va = va + PAGE_SIZE;
 		}
 	}
-	//cprintf("\n kernel sbrk called with number of pages = %d \n", numOfPages);
+//	cprintf("\n kernel sbrk called with number of pages = %d \n", numOfPages);
 	return (void *)previous_segBreak;
 	// MS2: COMMENT THIS LINE BEFORE START CODING==========
 	// return (void*)-1 ;
@@ -518,7 +518,7 @@ void *krealloc(void *virtual_address, uint32 new_size)
 		{
 			// cprintf("krealloc: reallocating a block to page section \n");
 			if (free_frames < new_pages)
-				return virtual_address;
+				return NULL;
 
 			new_address = kmalloc(new_size);
 

kern/mem/shared_memory_manager.c

@@ -221,13 +221,62 @@ int createSharedObject(int32 ownerID, char* shareName, uint32 size,
 		index_of_framesStorage++;
 	}
 	shared_obj->ID=(uint32)virtual_address& 0x7FFFFFFF;
+	// ---------- for free env
+	    myenv->shared_object_no+=1; //env created a shared obj
+
+	    if(myenv->shared_object_no == 1){
+	        myenv->startVAs = (uint32** )kmalloc(sizeof(int));
+	        myenv->startVAs[0] = (uint32 *)virtual_address;
+	    }else{
+	        uint32 *prevVAs[myenv->shared_object_no-1];
+	        for(int i=0; i<myenv->shared_object_no-1; i++)
+	            prevVAs[i] = myenv->startVAs[i];
+
+	            myenv->startVAs = (uint32 **)krealloc(myenv->startVAs, myenv->shared_object_no*sizeof(uint32));
+
+	            for(int i=0; i<myenv->shared_object_no-1; i++)
+	                myenv->startVAs[i] = prevVAs[i];
+
+	            myenv->startVAs[myenv->shared_object_no - 1] = (uint32*)virtual_address;
+
+	    }
+
+
+	    shared_obj->referenced_ids = NULL;
+	    shared_obj->refCounter = 0;
 	return shared_obj->ID;
 }
 
 
 //======================
 // [5] Get Share Object:
 //======================
+void adjustReferences(struct Share* sharedObj, struct Env * env, uint32 va){
+
+    // ignore the reference of the env that created shared object
+    int32 referencesNumber = sharedObj->references - 1;
+    int32 referenced_id = env->env_id;
+
+    // there's previous references need to store their values
+    if(referencesNumber != 1){
+        int32* prevIds[referencesNumber-1];
+
+        for(int i=0; i<referencesNumber-1; i++)
+            prevIds[i] = sharedObj->referenced_ids[i];
+
+        sharedObj->referenced_ids = (int32 **)krealloc(sharedObj->referenced_ids, referencesNumber*sizeof(int32));
+
+        for(int i=0; i<referencesNumber-1; i++)
+            sharedObj->referenced_ids[i] = prevIds[i];
+
+        sharedObj->referenced_ids[referencesNumber - 1] = (int32*)referenced_id;
+
+    }else{
+        sharedObj->referenced_ids = (int32 **)kmalloc(referencesNumber*sizeof(int32));
+        sharedObj->referenced_ids[0] = (int32*)referenced_id;
+    }
+
+}
 int getSharedObject(int32 ownerID, char* shareName, void* virtual_address)
 {
 	//TODO: [PROJECT'24.MS2 - #21] [4] SHARED MEMORY [KERNEL SIDE] - getSharedObject()
@@ -237,15 +286,15 @@ int getSharedObject(int32 ownerID, char* shareName, void* virtual_address)
 	struct Env* myenv = get_cpu_proc(); //The calling environment
 	struct Share* my_shared_object = get_share(ownerID, shareName);
 
-	bool lock_already_held = holding_spinlock(&AllShares.shareslock);
-	if (!lock_already_held) {
-		acquire_spinlock(&AllShares.shareslock);
-	}
+//	bool lock_already_held = holding_spinlock(&AllShares.shareslock);
+//	if (!lock_already_held) {
+//		acquire_spinlock(&AllShares.shareslock);
+//	}
 
 	if(my_shared_object==NULL){
-		if (!lock_already_held) {
-						release_spinlock(&AllShares.shareslock);
-			}
+//		if (!lock_already_held) {
+//						release_spinlock(&AllShares.shareslock);
+//			}
 		return E_SHARED_MEM_NOT_EXISTS;
 
 	}
@@ -268,9 +317,12 @@ int getSharedObject(int32 ownerID, char* shareName, void* virtual_address)
 
 	}
 	my_shared_object->references = my_shared_object->references + 1;
-	if (!lock_already_held) {
-		release_spinlock(&AllShares.shareslock);
-	}
+	my_shared_object->refCounter += 1;
+
+	    adjustReferences(my_shared_object, myenv, (uint32) virtual_address);
+//	if (!lock_already_held) {
+//		release_spinlock(&AllShares.shareslock);
+//	}
 	return my_shared_object->ID;
 }
 

kern/mem/shared_memory_manager.h

@@ -34,6 +34,9 @@ struct Share
 	// list link pointers
 	LIST_ENTRY(Share) prev_next_info;
 
+	int32 **referenced_ids;
+	    int refCounter;
+
 };
 
 //List of all shared objects