char *ft_get_first_line(int fd, t_map *map_info) { t_list *root; t_list *node; int deep; root = NULL; deep = 0; ft_list_push_back(&root); node = root; while (read(fd, &(node->c), 1) > 0) { deep++; if (node->c == '\n') return ((deep == 1) ? NULL : ft_list_to_tab(root, deep)); if (map_info) if (ft_strf(node->c, map_info->charset)) { ft_destroy(root); return (NULL); } ft_list_push_back(&node); node = node->next; } return (NULL); }
indigo_error_t ind_core_finish(void) { LOG_TRACE("OF state mgr finish called"); /* Indicate core is shutting down */ if (ind_core_module_enabled) { LOG_VERBOSE("Finish is calling disable"); ind_core_enable_set(0); } ft_destroy(ind_core_ft); ind_core_init_done = 0; return INDIGO_ERROR_NONE; }
/* * ft_create() * Creates a file table that is attached to the thread library. * */ struct filetable *ft_create() { //Allocate memory for the filetable structures struct filetable *ft = kmalloc(sizeof (struct filetable)); if (ft == NULL) { return NULL; } ft->size = 0; //Allocate memory for the array of file descriptors ft->filedescriptor = array_create(); if (ft->filedescriptor == NULL) { ft_destroy(ft); return NULL; } //preallocate the array to 20 files array_preallocate(ft->filedescriptor, 20); //Reserve the first three file descriptors for in out err. array_add(ft->filedescriptor, NULL); array_add(ft->filedescriptor, NULL); array_add(ft->filedescriptor, NULL); //Return the file table return ft; }
void ft_list_clear(t_list **begin_list) { ft_destroy(*begin_list); *begin_list = NULL; }
static void ft_destroy(t_list *list) { if (list->next != NULL) ft_destroy(list->next); free(list); }
/* * ft_attachstds() * Attach the standard in, out, err to the file table, this can't be located the * ft_create function because that the device "con:" etc are not attached to the * list of device when the os is the boot sequence. */ int ft_attachstds(struct filetable *ft) { char *console = NULL; int mode; int result = 0; //STDIN struct vnode *vn_stdin; mode = O_RDONLY; struct filedescriptor *fd_stdin = NULL; fd_stdin = (struct filedescriptor *) kmalloc(sizeof ( struct filedescriptor)); if (fd_stdin == NULL) { ft_destroy(ft); return 0; } console = kstrdup("con:"); result = vfs_open(console, mode, &vn_stdin); if (result) { vfs_close(vn_stdin); ft_destroy(ft); return 0; } kfree(console); fd_stdin->mode = mode; fd_stdin->offset = 0; fd_stdin->fdvnode = vn_stdin; fd_stdin->numOwners = 1; ft_set(ft, fd_stdin, STDIN_FILENO); //STDOUT struct vnode *vn_stdout; mode = O_WRONLY; struct filedescriptor *fd_stdout = NULL; fd_stdout = (struct filedescriptor *) kmalloc(sizeof (struct filedescriptor)); if (fd_stdout == NULL) { ft_destroy(ft); return 0; } console = kstrdup("con:"); result = vfs_open(console, mode, &vn_stdout); if (result) { vfs_close(vn_stdout); ft_destroy(ft); return 0; } kfree(console); fd_stdout->mode = mode; fd_stdout->offset = 0; fd_stdout->fdvnode = vn_stdout; fd_stdout->numOwners = 1; ft_set(ft, fd_stdout, STDOUT_FILENO); //STDERR struct vnode *vn_stderr; mode = O_WRONLY; struct filedescriptor *fd_stderr = NULL; fd_stderr = (struct filedescriptor *) kmalloc(sizeof (struct filedescriptor)); if (fd_stderr == NULL) { ft_destroy(ft); return 0; } console = kstrdup("con:"); result = vfs_open(console, mode, &vn_stderr); if (result) { vfs_close(vn_stderr); ft_destroy(ft); return 0; } kfree(console); fd_stderr->mode = mode; fd_stderr->offset = 0; fd_stderr->fdvnode = vn_stderr; fd_stderr->numOwners = 1; ft_set(ft, fd_stderr, STDERR_FILENO); return 1; }
ft_instance_t ft_create(ft_config_t *config) { ft_instance_t ft; int bytes; int idx; if (config->max_entries <= 0) { LOG_ERROR("Hash flow table only supports fixed number of buckets"); return NULL; } /* Allocate the flow table itself */ ft = INDIGO_MEM_ALLOC(sizeof(*ft)); if (ft == NULL) { LOG_ERROR("ERROR: Flow table (hash) creation failed"); return NULL; } INDIGO_MEM_SET(ft, 0, sizeof(*ft)); INDIGO_MEM_COPY(&ft->config, config, sizeof(ft_config_t)); list_init(&ft->free_list); list_init(&ft->all_list); /* Allocate and init the flow entries */ bytes = sizeof(ft_entry_t) * config->max_entries; ft->flow_entries = INDIGO_MEM_ALLOC(bytes); if (ft->flow_entries == NULL) { LOG_ERROR("ERROR: Flow table (hash) creation failed"); INDIGO_MEM_FREE(ft); return NULL; } INDIGO_MEM_SET(ft->flow_entries, 0, bytes); /* Put the flow entries on the free list */ for (idx = 0; idx < config->max_entries; idx++) { list_push(&ft->free_list, &ft->flow_entries[idx].table_links); } /* Allocate and init buckets for each search type */ bytes = sizeof(list_head_t) * config->prio_bucket_count; ft->prio_buckets = INDIGO_MEM_ALLOC(bytes); if (ft->prio_buckets == NULL) { LOG_ERROR("ERROR: Flow table, prio bucket alloc failed"); ft_destroy(ft); return NULL; } INDIGO_MEM_SET(ft->prio_buckets, 0, bytes); for (idx = 0; idx < config->prio_bucket_count; idx++) { list_init(&ft->prio_buckets[idx]); } bytes = sizeof(list_head_t) * config->match_bucket_count; ft->match_buckets = INDIGO_MEM_ALLOC(bytes); if (ft->match_buckets == NULL) { LOG_ERROR("ERROR: Flow table, match bucket alloc failed"); ft_destroy(ft); return NULL; } INDIGO_MEM_SET(ft->match_buckets, 0, bytes); for (idx = 0; idx < config->match_bucket_count; idx++) { list_init(&ft->match_buckets[idx]); } bytes = sizeof(list_head_t) * config->flow_id_bucket_count; ft->flow_id_buckets = INDIGO_MEM_ALLOC(bytes); if (ft->flow_id_buckets == NULL) { LOG_ERROR("ERROR: Flow table, flow id bucket alloc failed"); ft_destroy(ft); return NULL; } INDIGO_MEM_SET(ft->flow_id_buckets, 0, bytes); for (idx = 0; idx < config->flow_id_bucket_count; idx++) { list_init(&ft->flow_id_buckets[idx]); } return ft; }