directory.c File Reference

#include "filesys/directory.h"
#include <stdio.h>
#include <string.h>
#include <list.h>
#include "filesys/filesys.h"
#include "filesys/inode.h"
#include "threads/malloc.h"

Include dependency graph for directory.c:

Classes
struct	dir
struct	dir_entry

Functions
bool	dir_create (disk_sector_t sector, size_t entry_cnt)
struct dir *	dir_open (struct inode *inode)
struct dir *	dir_open_root (void)
struct dir *	dir_reopen (struct dir *dir)
void	dir_close (struct dir *dir)
struct inode *	dir_get_inode (struct dir *dir)
static bool	lookup (const struct dir *dir, const char *name, struct dir_entry *ep, off_t *ofsp)
bool	dir_lookup (const struct dir *dir, const char *name, struct inode **inode)
bool	dir_add (struct dir *dir, const char *name, disk_sector_t inode_sector)
bool	dir_remove (struct dir *dir, const char *name)
bool	dir_readdir (struct dir *dir, char name[NAME_MAX+1])

Function Documentation

dir_add()

bool dir_add	(	struct dir *	dir,
		const char *	name,
		disk_sector_t	inode_sector
	)

                                                                        {
    struct dir_entry e;
    off_t ofs;
    bool success = false;
 
    ASSERT (dir != NULL);
    ASSERT (name != NULL);
 
    /* Check NAME for validity. */
    if (*name == '\0' || strlen (name) > NAME_MAX)
        return false;
 
    /* Check that NAME is not in use. */
    if (lookup (dir, name, NULL, NULL))
        goto done;
 
    /* Set OFS to offset of free slot.
     * If there are no free slots, then it will be set to the
     * current end-of-file.
 
     * inode_read_at() will only return a short read at end of file.
     * Otherwise, we'd need to verify that we didn't get a short
     * read due to something intermittent such as low memory. */
    for (ofs = 0; inode_read_at (dir->inode, &e, sizeof e, ofs) == sizeof e;
            ofs += sizeof e)
        if (!e.in_use)
            break;
 
    /* Write slot. */
    e.in_use = true;
    strlcpy (e.name, name, sizeof e.name);
    e.inode_sector = inode_sector;
    success = inode_write_at (dir->inode, &e, sizeof e, ofs) == sizeof e;
 
done:
    return success;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_close()

void dir_close

(

struct dir *

dir

)

                            {
    if (dir != NULL) {
        inode_close (dir->inode);
        free (dir);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_create()

bool dir_create	(	disk_sector_t	sector,
		size_t	entry_cnt
	)

                                                    {
    return inode_create (sector, entry_cnt * sizeof (struct dir_entry));
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_get_inode()

struct inode * dir_get_inode

(

struct dir *

dir

)

                                {
    return dir->inode;
}

dir_lookup()

bool dir_lookup	(	const struct dir *	dir,
		const char *	name,
		struct inode **	inode
	)

                              {
    struct dir_entry e;
 
    ASSERT (dir != NULL);
    ASSERT (name != NULL);
 
    if (lookup (dir, name, &e, NULL))
        *inode = inode_open (e.inode_sector);
    else
        *inode = NULL;
 
    return *inode != NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_open()

struct dir * dir_open

(

struct inode *

inode

)

                               {
    struct dir *dir = calloc (1, sizeof *dir);
    if (inode != NULL && dir != NULL) {
        dir->inode = inode;
        dir->pos = 0;
        return dir;
    } else {
        inode_close (inode);
        free (dir);
        return NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_open_root()

struct dir * dir_open_root

(

void

)

                     {
    return dir_open (inode_open (ROOT_DIR_SECTOR));
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_readdir()

bool dir_readdir	(	struct dir *	dir,
		char	name[NAME_MAX+1]
	)

                                                       {
    struct dir_entry e;
 
    while (inode_read_at (dir->inode, &e, sizeof e, dir->pos) == sizeof e) {
        dir->pos += sizeof e;
        if (e.in_use) {
            strlcpy (name, e.name, NAME_MAX + 1);
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_remove()

bool dir_remove	(	struct dir *	dir,
		const char *	name
	)

                                               {
    struct dir_entry e;
    struct inode *inode = NULL;
    bool success = false;
    off_t ofs;
 
    ASSERT (dir != NULL);
    ASSERT (name != NULL);
 
    /* Find directory entry. */
    if (!lookup (dir, name, &e, &ofs))
        goto done;
 
    /* Open inode. */
    inode = inode_open (e.inode_sector);
    if (inode == NULL)
        goto done;
 
    /* Erase directory entry. */
    e.in_use = false;
    if (inode_write_at (dir->inode, &e, sizeof e, ofs) != sizeof e)
        goto done;
 
    /* Remove inode. */
    inode_remove (inode);
    success = true;
 
done:
    inode_close (inode);
    return success;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_reopen()

struct dir * dir_reopen

(

struct dir *

dir

)

                             {
    return dir_open (inode_reopen (dir->inode));
}

Here is the call graph for this function:

lookup()

static bool lookup ( const struct dir *  dir, const char *  name, struct dir_entry *  ep, off_t *  ofsp  )

static

                                           {
    struct dir_entry e;
    size_t ofs;
 
    ASSERT (dir != NULL);
    ASSERT (name != NULL);
 
    for (ofs = 0; inode_read_at (dir->inode, &e, sizeof e, ofs) == sizeof e;
            ofs += sizeof e)
        if (e.in_use && !strcmp (name, e.name)) {
            if (ep != NULL)
                *ep = e;
            if (ofsp != NULL)
                *ofsp = ofs;
            return true;
        }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function: