Ejemplo n.º 1
0
static int test_initfree_env(void)
{
   process_t         child = process_FREE;
   process_result_t  result;

   TEST(0 == init_process(&child, &childprocess_environment, 0, &(process_stdio_t)process_stdio_INIT_INHERIT));
   TEST(0 == wait_process(&child, &result));
   TEST(0 == free_process(&child));
   TEST(process_state_TERMINATED == result.state);
   TEST(0 == result.returncode);

   return 0 ;
ONERR:
   TEST(0 == free_process(&child));
   return EINVAL ;
}
Ejemplo n.º 2
0
/**
	process_close : 'process -> void
	<doc>
	Close the process I/O.
	</doc>
**/
CAMLprim value process_close( value vp ) {
	val_check_kind(vp,k_process);
	free_process(vp);
	//val_kind(vp) = NULL;
	//val_gc(vp,NULL);
	return val_null;
}
Ejemplo n.º 3
0
/**
	process_close : 'process -> void
	<doc>
	Close the process I/O.
	</doc>
**/
static value process_close( value vp ) {	
	val_check_kind(vp,k_process);
	free_process(vp);
	val_kind(vp) = NULL;
	val_gc(vp,NULL);
	return val_null;
}
Ejemplo n.º 4
0
extern OBJ _AWait_Ahc_Awaitpid(OBJ x1,OBJ x2) /* hc_waitpid */
{OBJ r;
 pid_t tmppid;
  free_some(x2,1);
  tmppid=((PROCESS)(x1))->value;
  free_process(x1,1);
  r=hc_wait(tmppid,0);
 return r;}
Ejemplo n.º 5
0
extern OBJ _AWait_Ahc_Awaitgrp_Anb(OBJ x1,OBJ x2) /* hc_waitgrp_nb */
{OBJ r;
 pid_t tmppid;
  free_some(x2,1);
  tmppid=((PROCESS)(x1))->value;
  free_process(x1,1);
  r=hc_wait(-tmppid,WNOHANG);
 return r;}
Ejemplo n.º 6
0
static int allocate_resources(process *proc, queue *q_ready, queue *q_process, queue *q_wait)
{
	if (!vector_leq(proc->request_vector, SYSTEM_RES)) {
		print_state_info(proc);
		printf("Process requested more resources than the system has available.\n");
		if (!empty_queue(q_process)) {
			int process_index = proc->row_index;
			free_process(proc);

			process *new_proc = (process *) dequeue(q_process);
			new_proc->row_index = process_index;

			clear_row_vector(allocation_matrix[new_proc->row_index]);
			clear_row_vector(claim_matrix[new_proc->row_index]);

			increment_row_vector(new_proc->max_need_vector, claim_matrix[new_proc->row_index]);
			matrix_difference(claim_matrix, allocation_matrix, difference_matrix);
			enqueue(q_ready, new_proc);
		}
		free_process(proc);

		return FALSE;
	}
	if (!is_valid_request(proc)) {
		print_state_info(proc);
		move_to_wait(q_wait, proc);

		return -1;
	}
	if (is_no_deadlock(proc)) {
		/* the resulting state after allocation is safe therefore allocate the resources this process requires */
		increment_row_vector(proc->request_vector, allocation_matrix[proc->row_index]);
		decrement_row_vector(proc->request_vector, available_vector);
		matrix_difference(claim_matrix, allocation_matrix, difference_matrix);

		return 0;
	} else {
		/* allocation of resources could potentially lead to a deadlock therefore enqueue this process */
		printf("\n>>> DEADLOCK POTENTIALLY AVOIDED <<<\n");
		print_state_info(proc);
		move_to_wait(q_wait, proc);

		return -1;
	}
}
Ejemplo n.º 7
0
void free_job(job *j) {

    if(!j) return;

    free_job(j->next);

    free_process(j->process_list);
    
    free(j);
}
Ejemplo n.º 8
0
Archivo: dump.c Proyecto: DavidFeng/ci
int run_process(int argc, char **argv, int debug) {
  struct Process * pl = load_process(*argv);
  if (!pl) return -1;

  be = pl->be;
  bd = pl->bd;
  int r = run_c(argc, argv, debug, pl->main_addr);
  free_process(pl);
  return r;
}
Ejemplo n.º 9
0
void erts_do_exit_process(ErlProcess* p, Eterm reason) {
#if (DEBUG_OP == 1)
	char buf[45];
	sprintf(buf, "process %d exited with reason %d\n", p->id, reason);
	debug(buf);
#endif

	p->flags |= F_EXITING;

	//cancel timer;
	erts_cancel_timer(&p->timer);

	//delete potential interrupts
	delete_interrupt(p->id);

	//propagate information
	if(reason != atom_normal) {
		ErtsLink* link = p->links;

		Eterm* hp = (Eterm*)pvPortMalloc(4*sizeof(Eterm));
		hp[0] = make_arityval(3);
		hp[1] = atom_EXIT;
		hp[2] = p->id;
		hp[3] = reason;
		Eterm exit_message = make_tuple(hp);

		while(link != NULL) {
			ErlProcess* linked = (ErlProcess*)&proc_tab[pid2pix(link->pid)];

			if(!(linked->flags & F_EXITING)) {
				erts_remove_link(&linked->links, p->id);
			}

			if(linked->flags & F_TRAP_EXIT && reason != atom_kill) {
				erts_send_message(p, link->pid, exit_message, 0);
			}
			else {
				if(!(linked->flags & F_EXITING)) {
					erts_do_exit_process(linked, reason);
				}
			}
			link = link->next;
		}

		vPortFree(hp);
	}

	//clean flags since they will be reused
	free_process(p);

	suspended++;
	vTaskSuspend(*(p->handle));
	continued++;
}
Ejemplo n.º 10
0
/* *** External visible functions *** */
void elect()
{
	// Delete current if terminated (so a terminated process does not wait at the end of list)
	if (current_process->status == TERMINATED)
	{
		terminate_if_last_process();

		current_process->previous->next = current_process->next;
		current_process->next->previous = current_process->previous;
		
		struct pcb_s* process_to_delete = current_process;
		
		choose_next_process();
		
		free_process(process_to_delete);
	}
	else if (current_process->status  == BLOCKED)
	{
		choose_next_process();
	}
	else
	{
		current_process->status = READY;
		choose_next_process();
	}
	
	#if DEBUG
	#if FB
		fb_print_char('\n');
		fb_print_text("The process with PID ");
		fb_print_int(current_process->pid);
		fb_print_text(" chosen with priority ");
		fb_print_int(current_process->priority);
		fb_print_char('\n');
		
	#else
		
		log_str("\n The process with PID ");
		log_int(current_process->pid);
		log_str(" chosen with priority ");
		log_int(current_process->priority);
		log_str("\n");
		
	#endif	
	#endif
	
	if (current_process->status == TERMINATED || current_process->status  == BLOCKED)
		elect(); // Elect the next one, and delete the current one
	else
		current_process->status = RUNNING; // Else, this one is now running
}
Ejemplo n.º 11
0
void		free_process(t_process *process)
{
  t_process	*tmp;

  while (process != NULL)
    {
      free(process->reg);
      if (process->child != NULL)
	free_process(process->child);
      tmp = process;
      process = process->next;
      free(tmp);
    }
}
Ejemplo n.º 12
0
Archivo: dump.c Proyecto: DavidFeng/ci
int save_process(const char * process_file,
    int * e, int * be, char * data, char * bd, int * sym) {
  struct Process * p = create_process(e, be, data, bd, sym);
  if (p == NULL) return -1;

  FILE * f = fopen(process_file, "wb");

  fwrite(&p->main_addr, sizeof(p->main_addr), 1, f);
  fwrite(&p->text_size, sizeof(p->text_size), 1, f);
  fwrite(&p->data_size, sizeof(p->data_size), 1, f);
  fwrite(p->be, 1, p->text_size, f);
  fwrite(p->bd, 1, p->data_size, f);

  fclose(f);

  free_process(p);

  return 0;
}
Ejemplo n.º 13
0
static void free_process(process *p) {

    if(!p) return;

    free_process(p->next);

    if(p->program_name) free(p->program_name);
    if(p->input_redirection) free(p->input_redirection);
    if(p->output_redirection) free(p->output_redirection);
    
    if(p->argument_list) {
	int i;
	for(i=0; p->argument_list[i] != NULL; i++)
	    free(p->argument_list[i]);
	free(p->argument_list);
    }

    free(p);
}
Ejemplo n.º 14
0
int waitpid(int pid)
{
  if(current->proc->flags & PROC_FLAG_DEBUG)
  {
    debug("[info]WAITPID(%d)\n", pid);
  }
  process_t *proc = get_process(pid);

  while(proc->state != PROC_STATE_FINISHED)
  {
    scheduler_sleep(current, &proc->waiting);
    
    schedule();
  }

  int ret = proc->exit_code;
  free_process(proc);

  errno = 0;
  return ret;
}
Ejemplo n.º 15
0
static int deallocate_resources(process *proc, queue *q_ready, queue *q_process, queue *q_wait, int is_end)
{
	if (is_end) {
		printf("\nSUCCESSFULLY TERMINATED PROCESS WITH PID %u\n", proc->pid);
		increment_row_vector(allocation_matrix[proc->row_index], available_vector);
		clear_row_vector(allocation_matrix[proc->row_index]);
		clear_row_vector(claim_matrix[proc->row_index]);

		if (load_from_wait(q_wait, q_ready)) {	/* attempt to load a process from the wait state */
			free_process(proc);
			return -1;
		}

		if (empty_queue(q_process)) {		/* no processes in the wait state so attempt to load from process queue */
			free_process(proc);
			return -1;
		}
		process *new_proc = (process *) dequeue(q_process);
		new_proc->row_index = proc->row_index;

		increment_row_vector(new_proc->max_need_vector, claim_matrix[new_proc->row_index]);
		matrix_difference(claim_matrix, allocation_matrix, difference_matrix);
		enqueue(q_ready, new_proc);
		free_process(proc);

		return -1;
	} else if (!vector_leq(proc->release_vector, allocation_matrix[proc->row_index])) {
		increment_row_vector(allocation_matrix[proc->row_index], available_vector);

		printf("\nProcess with PID %u ", proc->pid);
		print_row_vector(proc->release_vector, "attempted to release");
		print_row_vector(allocation_matrix[proc->row_index], "but only has allocated");

		clear_row_vector(allocation_matrix[proc->row_index]);
		clear_row_vector(claim_matrix[proc->row_index]);

		printf("\nABNORMAL TERMINATION OF PROCESS WITH PID %u\n", proc->pid);
		if (load_from_wait(q_wait, q_ready)) {
			free_process(proc);
			return -1;
		} else {
			if (empty_queue(q_process)) {
				free_process(proc);
				return -1;
			}
			process *new_proc = (process *) dequeue(q_process);
			new_proc->row_index = proc->row_index;

			increment_row_vector(new_proc->max_need_vector, claim_matrix[new_proc->row_index]);
			matrix_difference(claim_matrix, allocation_matrix, difference_matrix);
			enqueue(q_ready, new_proc);

			free_process(proc);

			return -1;
		}
	} else {		/* case were we can deallocate resources and have not reached an "END" instruction */
		decrement_row_vector(proc->release_vector, allocation_matrix[proc->row_index]);
		increment_row_vector(proc->release_vector, available_vector);
		matrix_difference(claim_matrix, allocation_matrix, difference_matrix);

		load_from_wait(q_wait, q_ready);	/* try to load one of the suspended processes */
		return 0;
	}
}
Ejemplo n.º 16
0
static int
widget_update (struct widget *widget, struct widget_config config) {
	CURL *curl;
	CURLcode status;
	char *data;
	long code;

	/* connect and handle IMAP responses */
	curl = curl_easy_init();
	data = malloc(CURL_BUF_SIZE);
	if (!curl || !data) {
		return 0;
	}

	write_result_t write_result = {
		.data = data,
		.pos = 0
	};

	curl_easy_setopt(curl, CURLOPT_USERNAME, config.username);
	curl_easy_setopt(curl, CURLOPT_PASSWORD, config.password);
	curl_easy_setopt(curl, CURLOPT_URL, config.address);
	curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "SEARCH UNSEEN");

	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, candybar_curl_write_response);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &write_result);

	if (config.ssl_verify) {
		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
	}

	status = curl_easy_perform(curl);
	if (status != CURLE_OK) {
		LOG_ERR("unable to request data from %s (this error may be temporary): %s",
		        config.address,
		        curl_easy_strerror(status));

		return 0;
	}

	curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);

	if (code != 0) {
		LOG_ERR("server responded with code %ld", code);

		return 0;
	}

	curl_easy_cleanup(curl);
	curl_global_cleanup();

	data[write_result.pos] = '\0';

	/* count unread message IDs */

	/* the server responds with a string like "* SEARCH 1 2 3 4" where the
	   numbers are message IDs */
	char *str, *saveptr, *delim = " *";
	int unread = -1;

	str = strtok_r(data, delim, &saveptr);
	while (str != NULL) {
		str = strtok_r(NULL, delim, &saveptr);
		unread++;
	}

	free(data);

	widget_data_callback(widget,
	                     widget_data_arg_number(unread),
	                     widget_data_arg_string(config.username));

	return 0;
}

static const char*
next (const char *ch, int space) {
	while (*ch && !isspace(*ch) == !space) {
		++ch;
	}

	return ch;
}

static int
parse_cmdline_arguments (const char *password_command, struct Process *proc) {
	const char *start = next(password_command, 1);
	if (!*start) {
		return -1;
	}
	const char *end = next(start, 0);
	if (!*end) {
		proc->path = strdup(start);
	}
	else {
		proc->path = strndup(start, end - start);
	}
	proc->argv = calloc(1024, sizeof(char*));
	proc->argv[0] = proc->path;
	int argv_idx = 1;

	while ((start = next(end, 1))) {
		end = next(start, 0);
		if (!*end) {
			proc->argv[argv_idx++] = strdup(start);
			break;
		}
		else {
			proc->argv[argv_idx++] = strndup(start, end - start);
		}
	}

	return 1;
}

void*
widget_main (struct widget *widget) {
	struct widget_config config = widget_config_defaults;
	widget_init_config_string(widget->config, "address", config.address);
	widget_init_config_string(widget->config, "username", config.username);
	widget_init_config_string(widget->config, "password", config.password);
	widget_init_config_string(widget->config, "password_command", config.password_command);
	widget_init_config_boolean(widget->config, "ssl_verify", config.ssl_verify);
	widget_init_config_integer(widget->config, "refresh_interval", config.refresh_interval);

	if (!config.username) {
		LOG_INFO("email_imap: username not set, disabling widget");

		return 0;
	}

	struct Buffer buffer;
	memset(&buffer, 0, sizeof(buffer));
	if (strlen(config.password_command)) {
		struct Process proc;
		memset(&proc, 0, sizeof(proc));
		proc.stderr_cb = write_stderr;
		proc.stdout_cb = write_stdout;
		proc.user_data = &buffer;
		if (parse_cmdline_arguments(config.password_command, &proc) == -1) {
			LOG_ERR("email_imap: cannot parse password_command: \"%s\"", config.password_command);

			return 0;
		}

		const int ret = process(&proc);
		free_process(&proc);
		if (ret != 0) {
			LOG_ERR("email_imap: process error: %s => %d: %s/%s\n", proc.path, ret, proc.error, buffer.stderr_buffer);

			return 0;
		}
		config.password = buffer.stdout_buffer;
	}

	widget_epoll_init(widget);
	while (true) {
		widget_update(widget, config);
		widget_epoll_wait_goto(widget, config.refresh_interval, cleanup);
	}

cleanup:

	widget_epoll_cleanup(widget);
	widget_clean_exit(widget);
	free_buffer(&buffer);
}
Ejemplo n.º 17
0
Archivo: exit.c Proyecto: OXKernel/ox
int kwaitpid(pid_t pid, WAIT_STATUS status, int options)
{
    struct process *curr = NULL;
    int i = 0, fixup = 0;

retry:

    for(i = 0; i < Nr_PRIORITY; ++i) {
        curr = process_tab[i];
        do {
            if(curr) {
                if(curr == current_process) {
                        curr = curr->p_next;
                        continue;
                }
                if(curr->p_parent != current_process->p_pid) {
                        curr = curr->p_next;
                        continue;
                }
                if(pid > 0) {
                    if(curr->p_pid != pid) {
                        curr = curr->p_next;
                        continue;
                    }
                } else if (pid == 0) {
                    if(curr->p_pgrp != current_process->p_pgrp) {
                        curr = curr->p_next;
                        continue;
                    }
                } else if (pid != -1) {
                    if(curr->p_pgrp != -pid) {
                        curr = curr->p_next;
                        continue;
                    }
                }
                if(curr->p_state == P_STOPPED) {
                    if(!(options & WUNTRACED)) {
                        curr = curr->p_next;
                        continue;
                    }
                    *status = 0x7F;
                    return curr->p_pid;
                } else if(curr->p_state == P_ZOMBIE) {
                    current_process->p_cutime += curr->p_utime;
                    current_process->p_cstime += curr->p_stime;
                    pid = curr->p_pid;
                    *status = curr->p_exit_code;
                    free_process(curr);  
                    return pid;
                } else {
                    fixup = 1;
                }
                curr = curr->p_next;
            } else {
                break;
            }
        } while(curr != process_tab[i]);
    }

    if(fixup) {
        if(options & WNOHANG) {
            return 0;
        }
        current_process->p_state = P_INTERRUPTIBLE;
        schedule();
        current_process->p_signal &= ~(1 << SIGCHLD);
        if(!(current_process->p_signal & (1 << SIGCHLD))) {
            goto retry;
        } else {
            return EINTR;
        }
        return ECHILD;
    }

}// kwaitpid
Ejemplo n.º 18
0
int main(int argc, char *argv[])
{
	char command[32];
	int eventsNr, eventId, procId, priority;
	int i, iteration;
	TStack **eventsStacks;
	TQueue *procQ;

	// Daca nu exista destule argumente la rularea programului, atunci opreste executia
	if (argc < 3)
	{
		printf("Argumente insuficiente!\n");
		return -1;
	}

	// Seteaza fisierele de intrare si de iesire
	freopen(argv[1], "r", stdin);
	freopen(argv[2], "w", stdout);

	// Citeste numarul de event-uri si creeaza stivele lor
	fscanf(stdin, "%d", &eventsNr);

	eventsStacks = calloc(eventsNr,  sizeof(TStack*));
	for (i = 0; i < eventsNr; i++)
	{
		eventsStacks[i] = stack_new(sizeof(TProcess));
	}

	// Creeaza coada de prioritati
	procQ = queue_new(sizeof(TProcess), compare_process);

	// Citeste si executa comenzile din fisierul de intrare
	iteration = 0;

	while (fscanf(stdin, "%s", command) != EOF)
	{
		iteration++;

		if (strcmp(command, "start") == 0)
		{
			fscanf(stdin, "%d", &procId);
			fscanf(stdin, "%d", &priority);

			// Creeaza un proces
			TProcess p;
			p.id = procId;
			p.priority = priority;
			p.iteration = iteration;

			// Introduce procesul creat in coada de prioritati
			queue_push(procQ, &p);
		}
		else if (strcmp(command, "wait") == 0)
		{
			fscanf(stdin, "%d", &eventId);
			fscanf(stdin, "%d", &procId);

			// Creaza o stiva auxiliara
			TStack *aux = stack_new(sizeof(TProcess));

			// Muta procesele in stiva auxiliara pana cand procesul
			// cautat este gasit si mutat in stiva evenimentului
			TProcess *p;
			while (!queue_isEmpty(procQ))
			{
				p = queue_pop(procQ);

				if (p->id == procId)
				{
					stack_push(eventsStacks[eventId], p);
					free_process(p);
					break;
				}
				
				stack_push(aux, p);
				free_process(p);
			}

			// Muta procesele din stiva auxiliara inapoi in coada
			// de prioritati
			while (!stack_isEmpty(aux))
			{
				p = stack_pop(aux);
				queue_push(procQ, p);
				free_process(p);
			}

			// Distruge stiva auxiliara
			stack_destroy(&aux, free_process);
		}
		else if (strcmp(command, "event") == 0)
		{
			fscanf(stdin, "%d", &eventId);

			// Muta procesele din stiva evenimentului in coada
			// de prioritati
			TProcess *p;
			while (!stack_isEmpty(eventsStacks[eventId]))
			{
				p = stack_pop(eventsStacks[eventId]);
				queue_push(procQ, p);
				free_process(p);
			}
		}
		else if (strcmp(command, "end") == 0)
		{
			fscanf(stdin, "%d", &procId);

			// Creaza o stiva auxiliara
			TStack *aux = stack_new(sizeof(TProcess));

			// Muta procesele in stiva auxiliara pana cand procesul
			// cautat este gasit si sters
			TProcess *p;
			while (!queue_isEmpty(procQ))
			{
				p = queue_pop(procQ);

				if (p->id == procId)
				{
					free_process(p);
					break;
				}
				
				stack_push(aux, p);
				free_process(p);
			}

			// Muta procesele din stiva auxiliara inapoi in coada
			// de prioritati
			while (!stack_isEmpty(aux))
			{
				p = stack_pop(aux);
				queue_push(procQ, p);
				free_process(p);
			}

			// Distruge stiva auxiliara
			stack_destroy(&aux, free_process);
		}

		// Afiseaza iteratia
		printf("%d\n", iteration);

		// Afiseaza coada de prioritati
		if (!queue_isEmpty(procQ))
		{
			queue_print(procQ, print_process);
		}
		else
		{
			printf("\n");
		}

		// Afiseaza stivele
		for (i = 0; i < eventsNr; i++)
		{
			if (!stack_isEmpty(eventsStacks[i]))
			{
				printf("%d: ", i);
				stack_print(eventsStacks[i], print_process);
			}
		}

		printf("\n");
	}

	// Elibereaza memoria
	queue_destroy(&procQ, free_process);

	for (i = 0; i < eventsNr; i++)
	{
		stack_destroy(&eventsStacks[i], free_process);
	}
	free(eventsStacks);

	return 0;
}