예제 #1
0
파일: module.c 프로젝트: aaliang/ramdisk_fs
//rd_open, will require a pid, really only accessible via the kernel
int rd_open(char* pathname){
	char *dir_path;
	char *filename;

	int pid = 5; //for now its five, fix this later when we aren't in userspace


	split_dir_file(pathname, &dir_path, &filename);

	int root_check = strcmp(dir_path, "/");
	if(filename != NULL && root_check == 0){
		int new_fd = allocate_fd(pid, 0);
		printf("rd_open success\n");
		return new_fd;
	}
	
	int find_inode = get_dir_inode(dir_path, 0);
	//search if such a directory exists
	if(find_inode > -1){
		find_inode = get_dir_entry(find_inode, filename, 0);
		if(find_inode > -1){
			int new_fd = allocate_fd(pid, find_inode);
			printf("rd_open success\n");
			return new_fd;
		}
	}
	printf("rd_open failed\n");
	return -1;
}
예제 #2
0
파일: module.c 프로젝트: aaliang/ramdisk_fs
int rd_creat(char* pathname){
	char *dir_path;
	char *filename;
	split_dir_file(pathname, &dir_path, &filename);
	int dir_inode_num = get_dir_inode(dir_path, 1); //check if dir_path exists
	if(dir_inode_num == -1){
		return -1;
	}
	int tmp = get_dir_entry(dir_inode_num, filename, 1);
	if(tmp != -1){
		//directory already exists
		printf("error: dir already exists\n");
		return -1;
	}
	//get ready to allocate inode
	int index = get_free_inode();
	if(index == -1){
		printf("no free inodes\n");
		return -1;
	}
	s_block->free_inodes = s_block->free_inodes - 1;
	init_inode(index, 2); //type = 2, regular file
	
	inode_array[dir_inode_num].size = inode_array[dir_inode_num].size + sizeof(dir_entry);
	dir_entry* new_dir = get_free_dir_entry(dir_inode_num);
	new_dir->inode_number = index;
	strcpy(new_dir->filename, filename);		

	printf("rd_creat created a file\n");
	return 1;
}
예제 #3
0
static void follow_chain(struct fat32_fs *fs, unsigned int start_cluster)
{
    int next = start_cluster;
    while (next != -1) {
        if (next == 0) {
            kprintf("unused\n");
        } else if (next == -2) {
            kprintf("bad cluster\n");
        } else {
            struct fat_dir_entry *dir = get_dir_entry(fs, next);
            if (dir == NULL) {
                kprintf("not on disk\n");
            } else {
                kprintf("on disk: `%s`\n", dir->dirname);
            }
        }
        next = next_cluster(fs, next);
    }
    kprintf("EOC\n");
}
예제 #4
0
void list_dirs(struct fat32_fs *fs)
{
    int next, entry = 0;

    /* Grab the root dir first */
    next = fs->bs->fat32.root_cluster;
    struct fat_dir_entry *root = get_dir_entry(fs, next);
    if (root == NULL) {
        kprintf("no root?\n");
        return;
    } else {
        kprintf("found root at rel %d\n", next);
        kprintf("/\n");
    }

    entry = 1;
    while (entry < 256) {
        follow_chain(fs, entry);
        entry++;
    }

#if 0
    next = 0;
    while (next < 256) {
        unsigned int n = *(unsigned int *)&fs->table[next] & 0x0FFFFFFF;
        if (n >= 0x0FFFFFF8) {
            kprintf("next %d: n %X (EOC)\n", next, n);
            next++;
        } else if (n == 0) {
            kprintf("empty\n");
            break;
        } else {
            kprintf("next %d: n %X ", next, n);
            struct fat_dir_entry *dir = get_dir_entry(fs, next);
            if (dir == NULL) {
                kprintf("(not on disk)");
            } else {
                kprintf("(on disk `%s`)", dir->dirname);
            }
            kprintf("\n");
        }
    }

    next = next_cluster(fs, next);
    if (next != -1) {
        kprintf("root isn't EOC?\n");
        return;
    }
    next++;

    /* Iterate over until there are no more to read */
    //while ((next = next_cluster(fs, next)) != -1) {
    while (1) {
        struct fat_dir_entry *dir = get_dir_entry(fs, next);
        if (dir == NULL) {
            kprintf("no entry for rel %d?\n", next);
            next = next_cluster(fs, next);
        } else {
            kprintf("`%s`\n", dir->dirname);
            next = next_cluster(fs, next);
            if (next == -2) {
                /* Bad cluster */
            } else if (next == -1) {
                /* EOC */
                next++;
                continue;
            } else if (next == 0) {
                /* Unused */
            }
        }
    }
#endif
}
예제 #5
0
/**
* @brief 
*	Function to open a specific file mentioned in the path 
*	based on the incoming modes
* @param file_path
*	Pointer to the location of the file path string
* @param flags
*	Flags indicating the modes in which the file is to be opened
*
* @return Non-zero:File descriptor of the opened file
	  Zero    :File open is unsuccessful
*/
int file_open(const char *file_path,int flags)
{
	const char *path = file_path;
	const char *temp_path,*delim_strt;
	char shrt_file_name[SHRT_FILE_NAME_LEN];
	char long_file_name[LONG_FILE_NAME_LEN];
	int len = 0,fl_des = 0,crt_flag,i;
	int delim_cnt = 0;
	int mode;
        int extn_len_cnt = 0;
	int seq_num = 1;
	bool is_file_found;
	dir_entry *entry = NULL;
	file_info *info;
	u8 *pwd = root_directory;
	u32 strt_cluster = rt_dir_strt_clus;
	bool is_long_file_name = false;	

	sw_memset(long_file_name,SPACE_VAL,LONG_FILE_NAME_LEN);
	delim_cnt = find_depth(file_path);
	
	path = file_path;
	for(i=0;i<delim_cnt;i++){
		if(*path == DELIMITER){
			delim_strt = path;
			path++;
		}
		while((*path != EXTN_DELIMITER) && (*path != '\0') 
			&& (*path != DELIMITER) && (len < LONG_FILE_NAME_LEN)){
			long_file_name[len] = *path; 
			path++; 
			len++;
		}
		temp_path = path;
		if(*temp_path == EXTN_DELIMITER){
			temp_path++;
			while(*temp_path != DELIMITER && *temp_path != '\0'){
				extn_len_cnt++;
				temp_path++;
			}
		}
		if(len > FILE_NAME_SHRT_LEN || extn_len_cnt > FILE_NAME_EXTN_LEN)
			is_long_file_name = true;

		if(is_long_file_name){
			path = delim_strt;
			len = 0;
			if(*path == DELIMITER)
				path++;
			while(len < LONG_FILE_NAME_LEN  && *path != '\0'
                              && *path != DELIMITER){
                             	long_file_name[len] = *path;
                                path++;
                                len++;
                        }
			long_file_name[len] = '\0';
			if(entry){
				sw_free(entry);
				entry = NULL;
			}
			is_file_found = get_dir_entry(long_file_name,&entry,
										  pwd,strt_cluster,true);				
		}
		else{
			len = FILE_NAME_SHRT_LEN;
			while(len < SHRT_FILE_NAME_LEN  && *path != '\0' 
			      && *path != DELIMITER){ 
				if(*path == EXTN_DELIMITER)
					path++;
				long_file_name[len] = *path;
				path++;
				len++;
			}
			convert_to_uppercase(long_file_name); 
			if(entry){
				sw_free(entry);
				entry = NULL;
			}
			is_file_found = get_dir_entry(long_file_name,&entry,
										  pwd,strt_cluster,false);
		}
		if((is_file_found) & (i != delim_cnt - 1)){ 
			strt_cluster = (entry->strt_clus_hword)<<16 | 
				       (entry->strt_clus_lword);
			pwd = cluster_to_memory_addr(strt_cluster);
			len = 0;
			extn_len_cnt = 0;
			sw_memset(shrt_file_name,SPACE_VAL,SHRT_FILE_NAME_LEN);
			sw_memset(long_file_name,SPACE_VAL,LONG_FILE_NAME_LEN);
			is_long_file_name = false;
		}		
	}
	if(is_file_found){
		if(flags & FILE_WRITE){
			if(chk_file_lock(file_path) == -1)
				flags = FILE_READ;				
			if(entry->attr & ATTR_READ){
				sw_printf("Cannot open the file in write mode\n");
				return -1;
			}
		}
		info = (file_info*)sw_malloc(sizeof(file_info));
                fl_des = retrieve_file_info(info,entry,flags,
											dir_file_offset,file_path);
	}  
	else{
              	if((flags & FILE_CREATE_NEW) || (flags & FILE_CREATE_ALWAYS)
                   || (flags & FILE_WRITE)){
                	if(is_long_file_name){
				get_short_file_name(long_file_name,shrt_file_name,
									(char)seq_num);
				if(get_dir_entry(shrt_file_name,NULL,
								 pwd,strt_cluster,false) == true){
					while(get_dir_entry(shrt_file_name,NULL,
										pwd,strt_cluster,false)){
						seq_num++;
						get_short_file_name(long_file_name,
											shrt_file_name,'seq_num');
					}
				}
				convert_to_uppercase(shrt_file_name);
				crt_flag = create_file(long_file_name,
									   shrt_file_name,strt_cluster,&entry);
			}
			else
				crt_flag = create_file(NULL,long_file_name,strt_cluster,&entry);
                        if(crt_flag == 0)
				sw_printf("File creation success\n");
			info = (file_info*)sw_malloc(sizeof(file_info));
			fl_des = retrieve_file_info(info,entry,flags,
										dir_file_offset,file_path);
                }
	  	else
			return -1;
        }
	return fl_des;  
}
예제 #6
0
파일: module.c 프로젝트: aaliang/ramdisk_fs
int rd_unlink(char* pathname) {
	int pid = 5;
    char* dir;
    char* file;
	char* file_type;
    int parent_dir;
    int file_inode;
	int i, direct_count;
	int rem_inode, bp_count;
	pnode_fd_table* fd_unlink;
	single_indirect* single_block;
    double_indirect* double_block;

	// (4) error if root
    if (strcmp(pathname, "/") == 0) {
        return -1;
    }
    split_dir_file(pathname, &dir, &file);
    parent_dir = parent_dir_exists(dir);
    // (1) error if pathname/file doesn't exist
	if (parent_dir == -1) {
        //vfree(dir); 
		//vfree(file);
        return -1;
    }
    file_inode = get_dir_entry(parent_dir, file, 2);
	if (file_inode == -1) {
       // vfree(dir); 
		//vfree(file);
        return -1;
    }
	// (2) error if dir is non-empty
    file_type = inode_array[file_inode].type;
    if ((file_type == 1) && (inode_array[file_inode].size != 0)) {
        return -1;
    }
	// (3) error if trying to unlink open file
	fd_unlink = find_fd_list(fd_table, pid);
	if (fd_unlink->table[file_inode].inode_pointer == NULL) {
		//vfree(dir);
		//vfree(file);
		return -1;
	}
	rem_inode = unlinker(parent_dir, file, inode_array[file_inode].type);  

    inode_array[parent_dir].size -= 16;
    s_block->free_inodes += 1;
    inode_array[rem_inode].id = rem_inode;
    inode_array[rem_inode].allocated = 0;
    inode_array[rem_inode].size = 0;
    inode_array[rem_inode].type = 0;

	bp_count = inode_array[rem_inode].bp_count;
	if (bp_count > 8){
		direct_count = 8;
	} 
	else {direct_count = bp_count;}

	for(i = 0; i < direct_count; i++) {
		if (inode_array[rem_inode].block_pointer[i] == NULL){
			break;
		}
		memset(inode_array[rem_inode].block_pointer[i], 0, RAMDISK_BLOCK_SIZE);
	}
	// single indirect
    if (bp_count > 8) {
        single_block = (single_indirect*) inode_array[file_inode].block_pointer[8];
        for (i = 0; i < 64; i++) {
            if (!single_block->block_pointer[i]) {
                break;
            }

			memset(single_block->block_pointer[i], 0, RAMDISK_BLOCK_SIZE);
        }
    }
    //double indirect
    if (bp_count == 10) {
        double_block = (double_indirect*) inode_array[file_inode].block_pointer[9];
        for (i = 0; i < 64; i++) {
            if (!double_block->indirect_block_pointer[i]) {
                break;
            }
            for (i = 0; i < 64; i++) {
                if (!single_block->block_pointer[i]) {
                    break;
                }

				memset(single_block->block_pointer[i], 0, RAMDISK_BLOCK_SIZE);	
            }
        }
    }
    
    inode_array[rem_inode].bp_count = 0;

	printf("rd_unlink %s is now unlinked\n", pathname);
	return 0;
}