[SOLVED] CS file system Hive #include filesys/fsutil.h

#include filesys/fsutil.h
#include
#include
#include
#include
#include
#include filesys/directory.h
#include filesys/file.h
#include filesys/filesys.h
#include threads/malloc.h
#include threads/palloc.h
#include threads/vaddr.h

/* List files in the root directory. */
void
fsutil_ls (char **argv UNUSED)
{
struct dir *dir;
char name[NAME_MAX + 1];

printf (Files in the root directory:
);
dir = dir_open_root ();
if (dir == NULL)
PANIC (root dir open failed);
while (dir_readdir (dir, name))
printf (%s
, name);
dir_close (dir);
printf (End of listing.
);
}

/* Prints the contents of file ARGV[1] to the system console as
hex and ASCII. */
void
fsutil_cat (char **argv)
{
const char *file_name = argv[1];

struct file *file;
char *buffer;

printf (Printing %s to the console
, file_name);
file = filesys_open (file_name);
if (file == NULL)
PANIC (%s: open failed, file_name);
buffer = palloc_get_page (PAL_ASSERT);
for (;;)
{
off_t pos = file_tell (file);
off_t n = file_read (file, buffer, PGSIZE);
if (n == 0)
break;

hex_dump (pos, buffer, n, true);
}
palloc_free_page (buffer);
file_close (file);
}

/* Deletes file ARGV[1]. */
void
fsutil_rm (char **argv)
{
const char *file_name = argv[1];

printf (Deleting %s
, file_name);
if (!filesys_remove (file_name))
PANIC (%s: delete failed
, file_name);
}

/* Extracts a ustar-format tar archive from the scratch block
device into the Pintos file system. */
void
fsutil_extract (char **argv UNUSED)
{
static block_sector_t sector = 0;

struct block *src;
void *header, *data;

/* Allocate buffers. */
header = malloc (BLOCK_SECTOR_SIZE);
data = malloc (BLOCK_SECTOR_SIZE);
if (header == NULL || data == NULL)
PANIC (couldnt allocate buffers);

/* Open source block device. */
src = block_get_role (BLOCK_SCRATCH);
if (src == NULL)
PANIC (couldnt open scratch device);

printf (Extracting ustar archive from scratch device
into file system
);

for (;;)
{
const char *file_name;
const char *error;
enum ustar_type type;
int size;

/* Read and parse ustar header. */
block_read (src, sector++, header);
error = ustar_parse_header (header, &file_name, &type, &size);
if (error != NULL)
PANIC (bad ustar header in sector %PRDSNu (%s), sector 1, error);

if (type == USTAR_EOF)
{
/* End of archive. */
break;
}
else if (type == USTAR_DIRECTORY)
printf (ignoring directory %s
, file_name);
else if (type == USTAR_REGULAR)
{
struct file *dst;

printf (Putting %s into the file system
, file_name);

/* Create destination file. */
if (!filesys_create (file_name, size))
PANIC (%s: create failed, file_name);
dst = filesys_open (file_name);
if (dst == NULL)
PANIC (%s: open failed, file_name);

/* Do copy. */
while (size > 0)
{
int chunk_size = (size > BLOCK_SECTOR_SIZE
? BLOCK_SECTOR_SIZE
: size);
block_read (src, sector++, data);
if (file_write (dst, data, chunk_size) != chunk_size)
PANIC (%s: write failed with %d bytes unwritten,
file_name, size);
size -= chunk_size;
}

/* Finish up. */
file_close (dst);
}
}

/* Erase the ustar header from the start of the block device,
so that the extraction operation is idempotent.We erase
two blocks because two blocks of zeros are the ustar
end-of-archive marker. */
printf (Erasing ustar archive
);
memset (header, 0, BLOCK_SECTOR_SIZE);
block_write (src, 0, header);
block_write (src, 1, header);

free (data);
free (header);
}

/* Copies file FILE_NAME from the file system to the scratch
device, in ustar format.

The first call to this function will write starting at the
beginning of the scratch device.Later calls advance across
the device.This position is independent of that used for
fsutil_extract(), so `extract should precede all
`appends. */
void
fsutil_append (char **argv)
{
static block_sector_t sector = 0;

const char *file_name = argv[1];
void *buffer;
struct file *src;
struct block *dst;
off_t size;

printf (Appending %s to ustar archive on scratch device
, file_name);

/* Allocate buffer. */
buffer = malloc (BLOCK_SECTOR_SIZE);
if (buffer == NULL)
PANIC (couldnt allocate buffer);

/* Open source file. */
src = filesys_open (file_name);
if (src == NULL)
PANIC (%s: open failed, file_name);
size = file_length (src);

/* Open target block device. */
dst = block_get_role (BLOCK_SCRATCH);
if (dst == NULL)
PANIC (couldnt open scratch device);

/* Write ustar header to first sector. */
if (!ustar_make_header (file_name, USTAR_REGULAR, size, buffer))
PANIC (%s: name too long for ustar format, file_name);
block_write (dst, sector++, buffer);

/* Do copy. */
while (size > 0)
{
int chunk_size = size > BLOCK_SECTOR_SIZE ? BLOCK_SECTOR_SIZE : size;
if (sector >= block_size (dst))
PANIC (%s: out of space on scratch device, file_name);
if (file_read (src, buffer, chunk_size) != chunk_size)
PANIC (%s: read failed with %PROTd bytes unread, file_name, size);
memset (buffer + chunk_size, 0, BLOCK_SECTOR_SIZE chunk_size);
block_write (dst, sector++, buffer);
size -= chunk_size;
}

/* Write ustar end-of-archive marker, which is two consecutive
sectors full of zeros.Dont advance our position past
them, though, in case we have more files to append. */
memset (buffer, 0, BLOCK_SECTOR_SIZE);
block_write (dst, sector, buffer);
block_write (dst, sector, buffer + 1);

/* Finish up. */
file_close (src);
free (buffer);
}