Subversion Repositories or1k

/*

 *  linux/fs/umsdos/emd.c

 *

 *  Written 1993 by Jacques Gelinas

 *

 *  Extended MS-DOS directory handling functions

 */

#include <linux/types.h>

#include <linux/fcntl.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/msdos_fs.h>

#include <linux/umsdos_fs.h>

#include <linux/dcache.h>

#include <linux/pagemap.h>

#include <linux/delay.h>

void put_entry (struct umsdos_dirent *p, struct umsdos_dirent *q)

{

        p->name_len = q->name_len;

        p->flags = q->flags;

        p->nlink = cpu_to_le16(q->nlink);

        p->uid = cpu_to_le16(q->uid);

        p->gid = cpu_to_le16(q->gid);

        p->atime = cpu_to_le32(q->atime);

        p->mtime = cpu_to_le32(q->mtime);

        p->ctime = cpu_to_le32(q->ctime);

        p->rdev = cpu_to_le16(q->rdev);

        p->mode = cpu_to_le16(q->mode);

}

static void get_entry(struct umsdos_dirent *p, struct umsdos_dirent *q)

{

        p->name_len = q->name_len;

        p->name[p->name_len]='\0';

        p->flags = q->flags;

        p->nlink = le16_to_cpu (q->nlink);

        /* FIXME -- 32bit UID/GID issues */

        p->uid = le16_to_cpu (q->uid);

        p->gid = le16_to_cpu (q->gid);

        p->atime = le32_to_cpu (q->atime);

        p->mtime = le32_to_cpu (q->mtime);

        p->ctime = le32_to_cpu (q->ctime);

        p->rdev = le16_to_cpu (q->rdev);

        p->mode = le16_to_cpu (q->mode);

}

/*

 * Lookup the EMD dentry for a directory.

 *

 * Note: the caller must hold a lock on the parent directory.

 */

struct dentry *umsdos_get_emd_dentry(struct dentry *parent)

{

        struct dentry *demd;

        demd = umsdos_lookup_dentry(parent, UMSDOS_EMD_FILE,

                                        UMSDOS_EMD_NAMELEN, 1);

        return demd;

}

/*

 * Check whether a directory has an EMD file.

 *

 * Note: the caller must hold a lock on the parent directory.

 */

int umsdos_have_emd(struct dentry *dir)

{

        struct dentry *demd = umsdos_get_emd_dentry (dir);

        int found = 0;

        if (!IS_ERR(demd)) {

                if (demd->d_inode)

                        found = 1;

                dput(demd);

        }

        return found;

}

/*

 * Create the EMD file for a directory if it doesn't

 * already exist. Returns 0 or an error code.

 *

 * Note: the caller must hold a lock on the parent directory.

 */

int umsdos_make_emd(struct dentry *parent)

{

        struct dentry *demd = umsdos_get_emd_dentry(parent);

        int err = PTR_ERR(demd);

        if (IS_ERR(demd)) {

                printk("umsdos_make_emd: can't get dentry in %s, err=%d\n",

                        parent->d_name.name, err);

                goto out;

        }

        /* already created? */

        err = 0;

        if (demd->d_inode)

                goto out_set;

Printk(("umsdos_make_emd: creating EMD %s/%s\n",

parent->d_name.name, demd->d_name.name));

        err = msdos_create(parent->d_inode, demd, S_IFREG | 0777);

        if (err) {

                printk (KERN_WARNING

                        "umsdos_make_emd: create %s/%s failed, err=%d\n",

                        parent->d_name.name, demd->d_name.name, err);

        }

out_set:

        dput(demd);

out:

        return err;

}

/*

 * Read an entry from the EMD file.

 * Support variable length record.

 * Return -EIO if error, 0 if OK.

 *

 * does not change {d,i}_count

 */

int umsdos_emd_dir_readentry (struct dentry *demd, loff_t *pos, struct umsdos_dirent *entry)

{

        struct address_space *mapping = demd->d_inode->i_mapping;

        struct page *page;

        struct umsdos_dirent *p;

        int offs = *pos & ~PAGE_CACHE_MASK;

        int recsize;

        int ret = 0;

        page = read_cache_page(mapping, *pos>>PAGE_CACHE_SHIFT,

                        (filler_t*)mapping->a_ops->readpage, NULL);

        if (IS_ERR(page))

                goto sync_fail;

        wait_on_page(page);

        if (!Page_Uptodate(page))

                goto async_fail;

        p = (struct umsdos_dirent*)(kmap(page)+offs);

        /* if this is an invalid entry (invalid name length), ignore it */

        if( p->name_len > UMSDOS_MAXNAME )

        {

                printk (KERN_WARNING "Ignoring invalid EMD entry with size %d\n", entry->name_len);

                p->name_len = 0;

                ret = -ENAMETOOLONG; /* notify umssync(8) code that something is wrong */

                /* FIXME: does not work if we did 'ls -l' before 'udosctl uls' ?! */

        }

        recsize = umsdos_evalrecsize(p->name_len);

        if (offs + recsize > PAGE_CACHE_SIZE) {

                struct page *page2;

                int part = (char *)(page_address(page) + PAGE_CACHE_SIZE) - p->spare;

                page2 = read_cache_page(mapping, 1+(*pos>>PAGE_CACHE_SHIFT),

                                (filler_t*)mapping->a_ops->readpage, NULL);

                if (IS_ERR(page2)) {

                        kunmap(page);

                        page_cache_release(page);

                        page = page2;

                        goto sync_fail;

                }

                wait_on_page(page2);

                if (!Page_Uptodate(page2)) {

                        kunmap(page);

                        page_cache_release(page2);

                        goto async_fail;

                }

                memcpy(entry->spare,p->spare,part);

                memcpy(entry->spare+part,kmap(page2),

                                recsize+offs-PAGE_CACHE_SIZE);

                kunmap(page2);

                page_cache_release(page2);

        } else

                memcpy(entry->spare,p->spare,((char*)p+recsize)-p->spare);

        get_entry(entry, p);

        kunmap(page);

        page_cache_release(page);

        *pos += recsize;

        return ret;

async_fail:

        page_cache_release(page);

        page = ERR_PTR(-EIO);

sync_fail:

        return PTR_ERR(page);

}

/*

 * Write an entry in the EMD file.

 * Return 0 if OK, -EIO if some error.

 *

 * Note: the caller must hold a lock on the parent directory.

 */

int umsdos_writeentry (struct dentry *parent, struct umsdos_info *info,

                                int free_entry)

{

        struct inode *dir = parent->d_inode;

        struct umsdos_dirent *entry = &info->entry;

        struct dentry *emd_dentry;

        int ret;

        struct umsdos_dirent entry0,*p;

        struct address_space *mapping;

        struct page *page, *page2 = NULL;

        int offs;

        emd_dentry = umsdos_get_emd_dentry(parent);

        ret = PTR_ERR(emd_dentry);

        if (IS_ERR(emd_dentry))

                goto out;

        /* make sure there's an EMD file */

        ret = -EIO;

        if (!emd_dentry->d_inode) {

                printk(KERN_WARNING

                        "umsdos_writeentry: no EMD file in %s/%s\n",

                        parent->d_parent->d_name.name, parent->d_name.name);

                goto out_dput;

        }

        if (free_entry) {

                /* #Specification: EMD file / empty entries

                 * Unused entries in the EMD file are identified

                 * by the name_len field equal to 0. However to

                 * help future extension (or bug correction :-( ),

                 * empty entries are filled with 0.

                 */

                memset (&entry0, 0, sizeof (entry0));

                entry = &entry0;

        } else if (entry->name_len > 0) {

                memset (entry->name + entry->name_len, '\0',

                        sizeof (entry->name) - entry->name_len);

                /* #Specification: EMD file / spare bytes

                 * 10 bytes are unused in each record of the EMD. They

                 * are set to 0 all the time, so it will be possible

                 * to do new stuff and rely on the state of those

                 * bytes in old EMD files.

                 */

                memset (entry->spare, 0, sizeof (entry->spare));

        }

        /* write the entry and update the parent timestamps */

        mapping = emd_dentry->d_inode->i_mapping;

        offs = info->f_pos & ~PAGE_CACHE_MASK;

        ret = -ENOMEM;

        page = grab_cache_page(mapping, info->f_pos>>PAGE_CACHE_SHIFT);

        if (!page)

                goto out_dput;

        p = (struct umsdos_dirent *) (page_address(page) + offs);

        if (offs + info->recsize > PAGE_CACHE_SIZE) {

                ret = mapping->a_ops->prepare_write(NULL,page,offs,

                                        PAGE_CACHE_SIZE);

                if (ret)

                        goto out_unlock;

                page2 = grab_cache_page(mapping,

                                        (info->f_pos>>PAGE_CACHE_SHIFT)+1);

                if (!page2)

                        goto out_unlock2;

                ret = mapping->a_ops->prepare_write(NULL,page2,0,

                                        offs+info->recsize-PAGE_CACHE_SIZE);

                if (ret)

                        goto out_unlock3;

                put_entry (p, entry);

                memcpy(p->spare,entry->spare,

                        (char *)(page_address(page) + PAGE_CACHE_SIZE) - p->spare);

                memcpy(page_address(page2),

                                ((char*)entry)+PAGE_CACHE_SIZE-offs,

                                offs+info->recsize-PAGE_CACHE_SIZE);

                ret = mapping->a_ops->commit_write(NULL,page2,0,

                                        offs+info->recsize-PAGE_CACHE_SIZE);

                if (ret)

                        goto out_unlock3;

                ret = mapping->a_ops->commit_write(NULL,page,offs,

                                        PAGE_CACHE_SIZE);

                UnlockPage(page2);

                page_cache_release(page2);

                if (ret)

                        goto out_unlock;

        } else {

                ret = mapping->a_ops->prepare_write(NULL,page,offs,

                                        offs + info->recsize);

                if (ret)

                        goto out_unlock;

                put_entry (p, entry);

                memcpy(p->spare,entry->spare,((char*)p+info->recsize)-p->spare);

                ret = mapping->a_ops->commit_write(NULL,page,offs,

                                        offs + info->recsize);

                if (ret)

                        goto out_unlock;

        }

        UnlockPage(page);

        page_cache_release(page);

        dir->i_ctime = dir->i_mtime = CURRENT_TIME;

        mark_inode_dirty(dir);

out_dput:

        dput(emd_dentry);

out:

        Printk (("umsdos_writeentry /mn/: returning %d...\n", ret));

        return ret;

out_unlock3:

        UnlockPage(page2);

        page_cache_release(page2);

out_unlock2:

        ClearPageUptodate(page);

        kunmap(page);

out_unlock:

        UnlockPage(page);

        page_cache_release(page);

        printk ("UMSDOS:  problem with EMD file:  can't write\n");

        goto out_dput;

}

/*

 * General search, locate a name in the EMD file or an empty slot to

 * store it. if info->entry.name_len == 0, search the first empty

 * slot (of the proper size).

 *

 * Return 0 if found, -ENOENT if not found, another error code if

 * other problem.

 *

 * So this routine is used to either find an existing entry or to

 * create a new one, while making sure it is a new one. After you

 * get -ENOENT, you make sure the entry is stuffed correctly and

 * call umsdos_writeentry().

 *

 * To delete an entry, you find it, zero out the entry (memset)

 * and call umsdos_writeentry().

 *

 * All this to say that umsdos_writeentry must be called after this

 * function since it relies on the f_pos field of info.

 *

 * Note: the caller must hold a lock on the parent directory.

 */

/* #Specification: EMD file structure

 * The EMD file uses a fairly simple layout.  It is made of records

 * (UMSDOS_REC_SIZE == 64).  When a name can't be written in a single

 * record, multiple contiguous records are allocated.

 */

static int umsdos_find (struct dentry *demd, struct umsdos_info *info)

{

        struct umsdos_dirent *entry = &info->entry;

        int recsize = info->recsize;

        struct inode *emd_dir;

        int ret = -ENOENT;

        struct {

                off_t posok;    /* Position available to store the entry */

                off_t one;      /* One empty position -> maybe <- large enough */

        } empty;

        int found = 0;

        int empty_size = 0;

        struct address_space *mapping;

        filler_t *readpage;

        struct page *page = NULL;

        int index = -1;

        int offs = PAGE_CACHE_SIZE,max_offs = PAGE_CACHE_SIZE;

        char *p = NULL;

        loff_t pos = 0;

        /* make sure there's an EMD file ... */

        ret = -ENOENT;

        emd_dir = demd->d_inode;

        if (!emd_dir)

                goto out_dput;

        mapping = emd_dir->i_mapping;

        readpage = (filler_t*)mapping->a_ops->readpage;

        empty.posok = emd_dir->i_size;

        while (1) {

                struct umsdos_dirent *rentry;

                int entry_size;

                if (offs >= max_offs) {

                        if (page) {

                                kunmap(page);

                                page_cache_release(page);

                                page = NULL;

                        }

                        if (pos >= emd_dir->i_size) {

                                info->f_pos = empty.posok;

                                break;

                        }

                        if (++index == (emd_dir->i_size>>PAGE_CACHE_SHIFT))

                                max_offs = emd_dir->i_size & ~PAGE_CACHE_MASK;

                        offs -= PAGE_CACHE_SIZE;

                        page = read_cache_page(mapping,index,readpage,NULL);

                        if (IS_ERR(page))

                                goto sync_fail;

                        wait_on_page(page);

                        if (!Page_Uptodate(page))

                                goto async_fail;

                        p = kmap(page);

                }

                rentry = (struct umsdos_dirent *)(p+offs);

                if (rentry->name_len == 0) {

                        /* We are looking for an empty section at least */

                        /* as large as recsize. */

                        if (entry->name_len == 0) {

                                info->f_pos = pos;

                                ret = 0;

                                break;

                        }

                        offs += UMSDOS_REC_SIZE;

                        pos += UMSDOS_REC_SIZE;

                        if (found)

                                continue;

                        if (!empty_size)

                                empty.one = pos-UMSDOS_REC_SIZE;

                        empty_size += UMSDOS_REC_SIZE;

                        if (empty_size == recsize) {

                                /* Here is a large enough section. */

                                empty.posok = empty.one;

                                found = 1;

                        }

                        continue;

                }

                entry_size = umsdos_evalrecsize(rentry->name_len);

                if (entry_size > PAGE_CACHE_SIZE)

                        goto async_fail;

                empty_size = 0;

                if (entry->name_len != rentry->name_len)

                        goto skip_it;

                if (entry_size + offs > PAGE_CACHE_SIZE) {

                        /* Sucker spans the page boundary */

                        int len = (p+PAGE_CACHE_SIZE)-rentry->name;

                        struct page *next_page;

                        char *q;

                        next_page = read_cache_page(mapping,index+1,readpage,NULL);

                        if (IS_ERR(next_page)) {

                                page_cache_release(page);

                                page = next_page;

                                goto sync_fail;

                        }

                        wait_on_page(next_page);

                        if (!Page_Uptodate(next_page)) {

                                page_cache_release(page);

                                page = next_page;

                                goto async_fail;

                        }

                        q = kmap(next_page);

                        if (memcmp(entry->name, rentry->name, len) ||

                            memcmp(entry->name+len, q, entry->name_len-len)) {

                                kunmap(next_page);

                                page_cache_release(next_page);

                                goto skip_it;

                        }

                        kunmap(next_page);

                        page_cache_release(next_page);

                } else if (memcmp (entry->name, rentry->name, entry->name_len))

                        goto skip_it;

                info->f_pos = pos;

                get_entry(entry, rentry);

                ret = 0;

                break;

skip_it:

                offs+=entry_size;

                pos+=entry_size;

        }

        if (page) {

                kunmap(page);

                page_cache_release(page);

        }

        umsdos_manglename (info);

out_dput:

        dput(demd);

        return ret;

async_fail:

        page_cache_release(page);

        page = ERR_PTR(-EIO);

sync_fail:

        return PTR_ERR(page);

}

/*

 * Add a new entry in the EMD file.

 * Return 0 if OK or a negative error code.

 * Return -EEXIST if the entry already exists.

 *

 * Complete the information missing in info.

 *

 * N.B. What if the EMD file doesn't exist?

 */

int umsdos_newentry (struct dentry *parent, struct umsdos_info *info)

{

        int err, ret = -EEXIST;

        struct dentry *demd = umsdos_get_emd_dentry(parent);

        ret = PTR_ERR(demd);

        if (IS_ERR(demd))

                goto out;

        err = umsdos_find (demd, info);

        if (err && err == -ENOENT) {

                ret = umsdos_writeentry (parent, info, 0);

                Printk (("umsdos_writeentry EMD ret = %d\n", ret));

        }

out:

        return ret;

}

/*

 * Create a new hidden link.

 * Return 0 if OK, an error code if not.

 */

/* #Specification: hard link / hidden name

 * When a hard link is created, the original file is renamed

 * to a hidden name. The name is "..LINKNNN" where NNN is a

 * number define from the entry offset in the EMD file.

 */

int umsdos_newhidden (struct dentry *parent, struct umsdos_info *info)

{

        int ret;

        struct dentry *demd = umsdos_get_emd_dentry(parent);

        ret = PTR_ERR(demd);

        if (IS_ERR(demd))

                goto out;

        umsdos_parse ("..LINK", 6, info);

        info->entry.name_len = 0;

        ret = umsdos_find (demd, info);

        if (ret == -ENOENT || ret == 0) {

                info->entry.name_len = sprintf (info->entry.name,

                                                "..LINK%ld", info->f_pos);

                ret = 0;

        }

out:

        return ret;

}

/*

 * Remove an entry from the EMD file.

 * Return 0 if OK, a negative error code otherwise.

 *

 * Complete the information missing in info.

 */

int umsdos_delentry (struct dentry *parent, struct umsdos_info *info, int isdir)

{

        int ret;

        struct dentry *demd = umsdos_get_emd_dentry(parent);

        ret = PTR_ERR(demd);

        if (IS_ERR(demd))

                goto out;

        ret = umsdos_find (demd, info);

        if (ret)

                goto out;

        if (info->entry.name_len == 0)

                goto out;

        if ((isdir != 0) != (S_ISDIR (info->entry.mode) != 0)) {

                if (S_ISDIR (info->entry.mode)) {

                        ret = -EISDIR;

                } else {

                        ret = -ENOTDIR;

                }

                goto out;

        }

        ret = umsdos_writeentry (parent, info, 1);

out:

        return ret;

}

/*

 * Verify that an EMD directory is empty.

 * Return:

 * 0 if not empty,

 * 1 if empty (except for EMD file),

 * 2 if empty or no EMD file.

 */

int umsdos_isempty (struct dentry *dentry)

{

        struct dentry *demd;

        int ret = 2;

        loff_t pos = 0;

        demd = umsdos_get_emd_dentry(dentry);

        if (IS_ERR(demd))

                goto out;

        /* If the EMD file does not exist, it is certainly empty. :-) */

        if (!demd->d_inode)

                goto out_dput;

        ret = 1;

        while (pos < demd->d_inode->i_size) {

                struct umsdos_dirent entry;

                if (umsdos_emd_dir_readentry (demd, &pos, &entry) != 0) {

                        ret = 0;

                        break;

                }

                if (entry.name_len != 0) {

                        ret = 0;

                        break;

                }

        }

out_dput:

        dput(demd);

out:

        return ret;

}

/*

 * Locate an entry in a EMD directory.

 * Return 0 if OK, error code if not, generally -ENOENT.

 *

 * expect argument:

 *      0: anything

 *      1: file

 *      2: directory

 */

int umsdos_findentry (struct dentry *parent, struct umsdos_info *info,

                        int expect)

{

        int ret;

        struct dentry *demd = umsdos_get_emd_dentry(parent);

        ret = PTR_ERR(demd);

        if (IS_ERR(demd))

                goto out;

        ret = umsdos_find (demd, info);

        if (ret)

                goto out;

        switch (expect) {

        case 1:

                if (S_ISDIR (info->entry.mode))

                        ret = -EISDIR;

                break;

        case 2:

                if (!S_ISDIR (info->entry.mode))

                        ret = -ENOTDIR;

        }

out:

        Printk (("umsdos_findentry: returning %d\n", ret));

        return ret;

}