Drop main() prototype. Syncs with NetBSD-8

[minix.git] / minix / fs / isofs / inode.c

/*
 * This file contains all the function that handle the dir records
 * (inodes) for the ISO9660 filesystem.
 */

#include "inc.h"

#include "uthash.h"

struct inode_cache {
        ino_t key;
        struct inode *value;
        UT_hash_handle hh;
} ;

struct inode_cache *icache = NULL;

void read_inode_iso9660(struct inode_dir_entry *i,
        const struct iso9660_dir_record *dir_rec, struct dir_extent *extent,
        size_t offset, int name_only);

#ifdef ISO9660_OPTION_MODE3
static void read_inode_extents(struct inode_dir_entry *i,
        const struct iso9660_dir_record *dir_rec, struct dir_extent *extent,
        size_t *offset);
#endif

#ifdef ISO9660_OPTION_ROCKRIDGE
void read_inode_susp(struct inode_dir_entry *i,
        const struct iso9660_dir_record *dir_rec, struct buf *bp, size_t offset,
        int name_only);
#endif

static int check_dir_record(const struct iso9660_dir_record *d, size_t offset);

int fs_putnode(ino_t ino_nr, unsigned int count)
{
       /*
        * Find the inode specified by the request message and decrease its
        * counter.
        */
        struct inode *i_node;

        if ((i_node = get_inode(ino_nr)) == NULL) {
                puts("ISOFS: trying to free unused inode");
                return EINVAL;
        }
        if (count > i_node->i_count) {
                puts("ISOFS: put_node count too high");
                return EINVAL;
        }

        i_node->i_count -= count - 1;
        put_inode(i_node);
        return OK;
}


struct inode* get_inode(ino_t ino_nr) {
        /* Return an already opened inode from cache. */
        struct inode *i_node = inode_cache_get(ino_nr);

        if (i_node == NULL)
                return NULL;

        if (i_node->i_count == 0)
                return NULL;

        return i_node;
}

struct inode* open_inode(ino_t ino_nr) {
        /* Return an inode from cache. */
        struct inode *i_node = inode_cache_get(ino_nr);
        if (i_node == NULL)
                return NULL;

        i_node->i_count++;

        return i_node;
}

void put_inode(struct inode *i_node) {
        if (i_node == NULL)
                return;

        assert(i_node->i_count > 0);
        i_node->i_count--;

        if(i_node->i_count == 0)
                i_node->i_mountpoint = FALSE;
}

void dup_inode(struct inode *i_node) {
        assert(i_node != NULL);
        assert(i_node->i_count > 0);

        i_node->i_count++;
}

int read_directory(struct inode *dir) {
#define MAX_ENTRIES 256         /* avoid using lots of stack.. */
        /* Read all entries in a directory. */
        size_t pos = 0, saved_pos, cur_entry, num_entries, cpt;
        struct inode_dir_entry entries[MAX_ENTRIES + 1];
        int status;

        if (dir->dir_contents)
                return OK;

        if (!S_ISDIR(dir->i_stat.st_mode))
                return ENOTDIR;

        /*
         * We do not know how many inode entries we will find, but we want to
         * allocate an array of the right size for dir->dir_contents.  First
         * find out how many entries there are, and store up to MAX_ENTRIES of
         * them into a temporary array on the stack.  If there are more than
         * MAX_ENTRIES entries, we have to do a second pass on the part of the
         * directory that we did not manage to fit in the temporary array.
         *
         * The entire service needs massive structural improvement (and in
         * particular, no dynamic memory allocation like this), but for now
         * this is the simplest way to be fast for small directories while at
         * the same time supporting seriously large directories.
         */
        cur_entry = 0;
        num_entries = 0;

        while ((status = read_inode(&entries[cur_entry], &dir->extent,
            &pos)) == OK) {
                /* Dump the entry if it's not to be exported to userland. */
                if (entries[cur_entry].i_node->skip) {
                        free_inode_dir_entry(&entries[cur_entry]);
                        continue;
                }

                if (cur_entry < MAX_ENTRIES) {
                        cur_entry++;

                        /*
                         * As long as more entries fit in the temporary array,
                         * update the saved position of the next entry.  Once
                         * we hit the first entry that does not fit (if any),
                         * the updating stops and we will have the correct
                         * saved position.
                         */
                        saved_pos = pos;
                } else {
                        /*
                         * No room in the temporary array.  Free the entry
                         * again.  This is costly but only for those rare
                         * directories that have more than MAX_ENTRIES entries.
                         */
                        free_inode_dir_entry(&entries[cur_entry]);
                }

                num_entries++;
        }

        /*
         * Allocate a dynamic array of the correct size, and populate it with
         * all the entries in the temporary array.  For large directories, the
         * temporary array will have partial results, in which case we have to
         * do a second pass on the rest below.
         */
        dir->dir_contents =
            alloc_mem(sizeof(struct inode_dir_entry) * num_entries);

        memcpy(dir->dir_contents, entries,
            sizeof(struct inode_dir_entry) * cur_entry);

        /*
         * The second pass.  This pass starts from the saved position and reads
         * only the entries that did not fit in the temporary array.  This time
         * we can read straight into the actual destination array.  We expect
         * to find the same entries as during the first pass.
         */
        while (cur_entry < num_entries) {
                if (read_inode(&dir->dir_contents[cur_entry], &dir->extent,
                    &saved_pos) != OK)
                        panic("unexpected EOF or error rereading directory");

                if (dir->dir_contents[cur_entry].i_node->skip) {
                        free_inode_dir_entry(&entries[cur_entry]);
                        continue;
                }

                cur_entry++;
        }

        dir->dir_size = num_entries;

        /* The name pointer has to point to the new memory location. */
        for (cpt = 0; cpt < num_entries; cpt++) {
                if (dir->dir_contents[cpt].r_name == NULL)
                        dir->dir_contents[cpt].name =
                            dir->dir_contents[cpt].i_name;
                else
                        dir->dir_contents[cpt].name =
                            dir->dir_contents[cpt].r_name;
        }

        return (status == EOF) ? OK : status;
}

int check_inodes(void) {
        /* Check whether there are no more inodes in use. Called on unmount. */
        int i;

        /* XXX: actually check for inodes in use. */
        return TRUE;
}

int read_inode(struct inode_dir_entry *dir_entry, struct dir_extent *extent,
        size_t *offset)
{
        struct iso9660_dir_record *dir_rec;
        struct buf *bp;
        struct inode *i_node;
        ino_t ino_nr;
        int name_only = FALSE;

        /* Find inode. */
        bp = read_extent_block(extent, *offset);
        if (bp == NULL) {
                return EOF;
        }

        /* Check if we are crossing a sector boundary. */
        dir_rec = (struct iso9660_dir_record*)(b_data(bp) + *offset %
                  v_pri.logical_block_size_l);

        if (dir_rec->length == 0) {
                *offset = ((*offset / v_pri.logical_block_size_l) + 1) *
                    v_pri.logical_block_size_l;

                lmfs_put_block(bp);
                bp = read_extent_block(extent, *offset);
                if (bp == NULL) {
                        return EOF;
                }

                dir_rec = (struct iso9660_dir_record*)(b_data(bp) + *offset %
                  v_pri.logical_block_size_l);
        }

        /* Parse basic ISO 9660 specs. */
        if (check_dir_record(dir_rec, *offset % v_pri.logical_block_size_l)
            != OK) {
                lmfs_put_block(bp);
                return EINVAL;
        }

        /* Get inode */
        if ((dir_rec->file_flags & D_TYPE) == D_DIRECTORY) {
                ino_nr = dir_rec->loc_extent_l;
        }
        else {
                ino_nr = get_extent_absolute_block_id(extent, *offset)
                    * v_pri.logical_block_size_l +
                    *offset % v_pri.logical_block_size_l;
        }

        memset(dir_entry, 0, sizeof(*dir_entry));

        i_node = inode_cache_get(ino_nr);
        if (i_node) {
                /* Inode was already loaded, parse file names only. */
                dir_entry->i_node = i_node;
                i_node->i_refcount++;

                memset(&dir_entry->i_name[0], 0, sizeof(dir_entry->i_name));

                name_only = TRUE;
        }
        else {
                /* Inode wasn't in memory, parse it. */
                i_node = alloc_mem(sizeof(struct inode));
                dir_entry->i_node = i_node;
                i_node->i_refcount = 1;
                i_node->i_stat.st_ino = ino_nr;
                inode_cache_add(ino_nr, i_node);
        }

        dir_entry->i_node = i_node;
        read_inode_iso9660(dir_entry, dir_rec, extent, *offset, name_only);

        /* Parse extensions. */
#ifdef ISO9660_OPTION_ROCKRIDGE
        read_inode_susp(dir_entry, dir_rec, bp,
            *offset % v_pri.logical_block_size_l, name_only);
#endif

        *offset += dir_rec->length;
        if (dir_rec->length % 2)
                (*offset)++;

#ifdef ISO9660_OPTION_MODE3
        read_inode_extents(dir_entry, dir_rec, extent, offset);
#endif

        lmfs_put_block(bp);

        return OK;
}

struct inode* inode_cache_get(ino_t ino_nr) {
        struct inode_cache *i_node;
        HASH_FIND(hh, icache, &ino_nr, sizeof(ino_t), i_node);

        if (i_node)
                return i_node->value;
        else
                return NULL;
}

void inode_cache_add(ino_t ino_nr, struct inode *i_node) {
        struct inode_cache *c_check;
        struct inode_cache *c_entry;

        HASH_FIND(hh, icache, &ino_nr, sizeof(ino_t), c_check);

        if (c_check == NULL) {
                c_entry = alloc_mem(sizeof(struct inode_cache));
                c_entry->key = ino_nr;
                c_entry->value = i_node;

                HASH_ADD(hh, icache, key, sizeof(ino_t), c_entry);
        }
        else
                panic("Trying to insert inode into cache twice");
}

void read_inode_iso9660(struct inode_dir_entry *i,
        const struct iso9660_dir_record *dir_rec, struct dir_extent *extent,
        size_t offset, int name_only)
{
        char *cp;

        /* Parse file name. */
        if (dir_rec->file_id[0] == 0)
                strcpy(i->i_name, ".");
        else if (dir_rec->file_id[0] == 1)
                strcpy(i->i_name, "..");
        else {
                memcpy(i->i_name, dir_rec->file_id, dir_rec->length_file_id);

                /* Truncate/ignore file version suffix. */
                cp = strchr(i->i_name, ';');
                if (cp != NULL) {
                        *cp = '\0';
                        /* Truncate dot if file has no extension. */
                        if (strchr(i->i_name, '.') + 1 == cp)
                                *(cp-1) = '\0';
                }
        }

        if (name_only == TRUE)
                return;

        /* Parse first extent. */
        if (dir_rec->data_length_l > 0) {
                i->i_node->extent.location = dir_rec->loc_extent_l +
                    dir_rec->ext_attr_rec_length;
                i->i_node->extent.length = dir_rec->data_length_l /
                    v_pri.logical_block_size_l;

                if (dir_rec->data_length_l % v_pri.logical_block_size_l)
                        i->i_node->extent.length++;

                i->i_node->i_stat.st_size = dir_rec->data_length_l;
        }

        /* Parse timestamps (record date). */
        i->i_node->i_stat.st_atime = i->i_node->i_stat.st_mtime =
            i->i_node->i_stat.st_ctime = i->i_node->i_stat.st_birthtime =
            date7_to_time_t(dir_rec->rec_date);

        if ((dir_rec->file_flags & D_TYPE) == D_DIRECTORY)
                i->i_node->i_stat.st_mode = S_IFDIR;
        else
                i->i_node->i_stat.st_mode = S_IFREG;

        i->i_node->i_stat.st_mode |= 0555;

        /* Initialize stat. */
        i->i_node->i_stat.st_dev = fs_dev;
        i->i_node->i_stat.st_blksize = v_pri.logical_block_size_l;
        i->i_node->i_stat.st_blocks = dir_rec->data_length_l / 512;
        i->i_node->i_stat.st_nlink = 1;
}

#ifdef ISO9660_OPTION_ROCKRIDGE

void read_inode_susp(struct inode_dir_entry *i,
        const struct iso9660_dir_record *dir_rec, struct buf *bp, size_t offset,
        int name_only)
{
        int susp_offset, susp_size, name_length;
        struct rrii_dir_record rrii_data;

        susp_offset = 33 + dir_rec->length_file_id;
        /* Get rid of padding byte. */
        if(dir_rec->length_file_id % 2 == 0) {
                susp_offset++;
        }

        if(dir_rec->length - susp_offset < 4)
                return;

        susp_size = dir_rec->length - susp_offset;

        /* Initialize record with known, sane data. */
        memcpy(rrii_data.mtime, dir_rec->rec_date, ISO9660_SIZE_DATE7);
        memcpy(rrii_data.atime, dir_rec->rec_date, ISO9660_SIZE_DATE7);
        memcpy(rrii_data.ctime, dir_rec->rec_date, ISO9660_SIZE_DATE7);
        memcpy(rrii_data.birthtime, dir_rec->rec_date, ISO9660_SIZE_DATE7);

        rrii_data.d_mode = i->i_node->i_stat.st_mode;
        rrii_data.uid    = SYS_UID;
        rrii_data.gid    = SYS_GID;
        rrii_data.rdev   = NO_DEV;
        rrii_data.file_id_rrip[0] = '\0';
        rrii_data.slink_rrip[0]   = '\0';
        rrii_data.reparented_inode = NULL;

        parse_susp_buffer(&rrii_data, b_data(bp)+offset+susp_offset, susp_size);

        /* Copy back data from rrii_dir_record structure. */
        if (rrii_data.file_id_rrip[0] != '\0') {
                name_length = strlen(rrii_data.file_id_rrip);
                i->r_name = alloc_mem(name_length + 1);
                memcpy(i->r_name, rrii_data.file_id_rrip, name_length);
        }

        if (rrii_data.slink_rrip[0] != '\0') {
                name_length = strlen(rrii_data.slink_rrip);
                i->i_node->s_name = alloc_mem(name_length + 1);
                memcpy(i->i_node->s_name, rrii_data.slink_rrip, name_length);
        }

        if (rrii_data.reparented_inode) {
                /* Recycle the inode already parsed. */
                i->i_node = rrii_data.reparented_inode;
                return;
        }

        /* XXX: not the correct way to ignore reparented directory holder... */
        if (strcmp(rrii_data.file_id_rrip, ".rr_moved") == 0)
                i->i_node->skip = 1;

        if (name_only == TRUE)
                return;

        /* Write back all Rock Ridge properties. */
        i->i_node->i_stat.st_atime = date7_to_time_t(rrii_data.atime);
        i->i_node->i_stat.st_ctime = date7_to_time_t(rrii_data.ctime);
        i->i_node->i_stat.st_mtime = date7_to_time_t(rrii_data.mtime);
        i->i_node->i_stat.st_birthtime = date7_to_time_t(rrii_data.birthtime);

        i->i_node->i_stat.st_mode = rrii_data.d_mode;
        i->i_node->i_stat.st_uid  = rrii_data.uid;
        i->i_node->i_stat.st_gid  = rrii_data.gid;
        i->i_node->i_stat.st_rdev = rrii_data.rdev;
}

#endif

#ifdef ISO9660_OPTION_MODE3

void read_inode_extents(struct inode *i,
        const struct iso9660_dir_record *dir_rec,
        struct dir_extent *extent, size_t *offset)
{
        panic("read_inode_extents() isn't implemented yet!");
}

#endif

int check_dir_record(const struct iso9660_dir_record *d, size_t offset) {
        /* Run some consistency check on a directory entry. */
        if ((d->length < 33) || (d->length_file_id < 1))
                return EINVAL;
        if (d->length_file_id + 32 > d->length)
                return EINVAL;
        if (offset + d->length > v_pri.logical_block_size_l)
                return EINVAL;

        return OK;
}