Exemplo n.º 1
0
/*
 * Lookup the data. This is trivial - if the dentry didn't already
 * exist, we know it is negative.
 */
static struct dentry * ptpfs_root_lookup(struct inode *dir, struct dentry *dentry)
{
//    printk(KERN_INFO "%s\n",  __FUNCTION__);

    struct ptp_storage_ids storageids;
    int x;
    char fsname[256];
    int typeCount[5];
    memset(&storageids,0,sizeof(storageids)); //add by evan
    memset(typeCount,0,sizeof(typeCount));

    if (ptp_getstorageids(PTPFSSB(dir->i_sb), &storageids)!=PTP_RC_OK)
	{
        printk(KERN_INFO "Error getting storage ids\n");
        storageids.n = 0;
        storageids.storage = NULL;
	}

    int offset = 0;
    for (x = 0; x < storageids.n; x++)
	{
        struct ptp_storage_info storageinfo;
        if ((storageids.storage[x]&0x0000ffff)==0) continue;

        memset(&storageinfo,0,sizeof(storageinfo));
        if (ptp_getstorageinfo(PTPFSSB(dir->i_sb), storageids.storage[x],&storageinfo)!=PTP_RC_OK)
 		{
            printk(KERN_INFO "Error getting storage info\n");
 		}
        else
        	{
            get_root_dir_name(&storageinfo,fsname,typeCount);
            offset++;
            if (!memcmp(fsname,dentry->d_name.name,dentry->d_name.len))
            		{
                struct inode *newi = ptpfs_get_inode(dir->i_sb, S_IFDIR | S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH , 0,storageids.storage[x]);
              PTPFSINO(newi)->parent = dir; //dir should be root directory
                //newi->i_fop = &ptpfs_stgdir_operations;
                //newi->i_op = &ptpfs_stgdir_inode_operations;
                PTPFSINO(newi)->type = INO_TYPE_STGDIR;
                PTPFSINO(newi)->storage = storageids.storage[x];
                if (newi) d_add(dentry, newi);
                ptp_free_storage_ids(&storageids);
                ptp_free_storage_info(&storageinfo);
                return NULL;
            		}
            ptp_free_storage_info(&storageinfo);
        	}
	}
    ptp_free_storage_ids(&storageids);
    return NULL;

}
Exemplo n.º 2
0
static struct dentry * ptpfs_lookup(struct inode *dir, struct dentry *dentry)
{
    int x;
    //printk(KERN_INFO "%s\n",  __FUNCTION__);

    struct ptpfs_inode_data* ptpfs_data = PTPFSINO(dir);
    if (!ptpfs_get_dir_data(dir))
    {
        d_add(dentry, NULL);
        return NULL;
    }
    if (ptpfs_data->type != INO_TYPE_DIR  && ptpfs_data->type != INO_TYPE_STGDIR)
    {
        d_add(dentry, NULL);
        return NULL;
    }
    for (x = 0; x < ptpfs_data->data.dircache.num_files; x++)
    {

        if (!memcmp(ptpfs_data->data.dircache.file_info[x].filename,dentry->d_name.name,dentry->d_name.len))
        {
            struct ptp_object_info object;
            if (ptp_getobjectinfo(PTPFSSB(dir->i_sb),ptpfs_data->data.dircache.file_info[x].handle,&object)!=PTP_RC_OK)
            {
                d_add(dentry, NULL);
                return NULL;
            }
            int mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH;
            if (object.object_format==PTP_OFC_Association && object.association_type == PTP_AT_GenericFolder)
            {
                mode |= S_IFDIR; 
            }
            else
            {
                mode |= S_IFREG;
            }
            struct inode *newi = ptpfs_get_inode(dir->i_sb, mode  , 0,ptpfs_data->data.dircache.file_info[x].handle);
            PTPFSINO(newi)->parent = dir;
            ptpfs_set_inode_info(newi,&object);
            //atomic_inc(&newi->i_count);    /* New dentry reference */
            d_add(dentry, newi);
            ptp_free_object_info(&object);
            return NULL;
        }
    }

    d_add(dentry, NULL);
    return NULL;
}
Exemplo n.º 3
0
static int ptpfs_create(struct inode *dir,struct dentry *d,int i) 
{
    //printk(KERN_INFO "%s   %s %d\n",__FUNCTION__,d->d_name.name,i);
    __u32 storage;
    __u32 parent;
    __u32 handle;
    struct ptp_object_info objectinfo;
    memset(&objectinfo,0,sizeof(objectinfo));

    storage = PTPFSINO(dir)->storage;
    if (PTPFSINO(dir)->type == INO_TYPE_STGDIR)
    {
        parent = 0xffffffff;
    }
    else
    {
        parent = dir->i_ino;
    }

    objectinfo.filename = (unsigned char *)d->d_name.name;
    objectinfo.object_format=get_format((unsigned char *)d->d_name.name,d->d_name.len);
    objectinfo.object_compressed_size=0;

    int ret = ptp_sendobjectinfo(PTPFSSB(dir->i_sb), &storage, &parent, &handle, &objectinfo);

    if (ret == PTP_RC_OK)
    {
        struct ptp_data_buffer data;
        struct ptp_block block;
        unsigned char buf[10];

        memset(&data,0,sizeof(data));
        memset(&block,0,sizeof(block));
        data.blocks=&block;
        data.num_blocks = 1;
        block.block_size = 0;
        block.block = buf;

        ret = ptp_sendobject(PTPFSSB(dir->i_sb),&data,0);


        if (handle == 0)
        {
            //problem - it didn't return the right handle - need to do something find it
            struct ptp_object_handles objects;
            objects.n = 0;
            objects.handles = NULL;

            ptpfs_get_dir_data(dir);
            if (PTPFSINO(dir)->type == INO_TYPE_DIR)
            {
                ptp_getobjecthandles(PTPFSSB(dir->i_sb), PTPFSINO(dir)->storage, 0x000000, dir->i_ino,&objects);
            }
            else
            {
                ptp_getobjecthandles(PTPFSSB(dir->i_sb), dir->i_ino, 0x000000, 0xffffffff ,&objects);
            }

            int x,y;
            for (x = 0; x < objects.n && !handle; x++ )
            {
                for (y = 0; y < PTPFSINO(dir)->data.dircache.num_files; y++)
                {
                    if (PTPFSINO(dir)->data.dircache.file_info[y].handle == objects.handles[x])
                    {
                        objects.handles[x] = 0;
                        y = PTPFSINO(dir)->data.dircache.num_files;
                    }
                }
                if (objects.handles[x])
                {
                    handle = objects.handles[x]; 
                }
            }
            ptp_free_object_handles(&objects);
        }


        int mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH | S_IFREG;
        struct inode *newi = ptpfs_get_inode(dir->i_sb, mode  , 0,handle);
        PTPFSINO(newi)->parent = dir;
        ptpfs_set_inode_info(newi,&objectinfo);
        atomic_inc(&newi->i_count);    /* New dentry reference */
        d_instantiate(d, newi);

        objectinfo.filename = NULL;
        ptp_free_object_info(&objectinfo);

        ptpfs_free_inode_data(dir);//uncache
        dir->i_version++;
        newi->i_mtime = CURRENT_TIME;
        return 0;
    }
    objectinfo.filename = NULL;
    ptp_free_object_info(&objectinfo);
    return -EPERM;


}