Added missing tegra files.HEADmaster

1 files changed, 182 insertions, 0 deletions

diff --git a/drivers/staging/pohmelfs/lock.c b/drivers/staging/pohmelfs/lock.c
new file mode 100644
index 00000000000..6710114cd42
--- /dev/null
+++ b/drivers/staging/pohmelfs/lock.c
@@ -0,0 +1,182 @@
+/*
+ * 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/backing-dev.h>
+#include <linux/fs.h>
+#include <linux/fsnotify.h>
+#include <linux/mempool.h>
+
+#include "netfs.h"
+
+static int pohmelfs_send_lock_trans(struct pohmelfs_inode *pi,
+                u64 id, u64 start, u32 size, int type)
+{
+        struct inode *inode = &pi->vfs_inode;
+        struct pohmelfs_sb *psb = POHMELFS_SB(inode->i_sb);
+        struct netfs_trans *t;
+        struct netfs_cmd *cmd;
+        int path_len, err;
+        void *data;
+        struct netfs_lock *l;
+        int isize = (type & POHMELFS_LOCK_GRAB) ? 0 : sizeof(struct netfs_inode_info);
+
+        err = pohmelfs_path_length(pi);
+        if (err < 0)
+                goto err_out_exit;
+
+        path_len = err;
+
+        err = -ENOMEM;
+        t = netfs_trans_alloc(psb, path_len + sizeof(struct netfs_lock) + isize,
+                        NETFS_TRANS_SINGLE_DST, 0);
+        if (!t)
+                goto err_out_exit;
+
+        cmd = netfs_trans_current(t);
+        data = cmd + 1;
+
+        err = pohmelfs_construct_path_string(pi, data, path_len);
+        if (err < 0)
+                goto err_out_free;
+        path_len = err;
+
+        l = data + path_len;
+
+        l->start = start;
+        l->size = size;
+        l->type = type;
+        l->ino = pi->ino;
+
+        cmd->cmd = NETFS_LOCK;
+        cmd->start = 0;
+        cmd->id = id;
+        cmd->size = sizeof(struct netfs_lock) + path_len + isize;
+        cmd->ext = path_len;
+        cmd->csize = 0;
+
+        netfs_convert_cmd(cmd);
+        netfs_convert_lock(l);
+
+        if (isize) {
+                struct netfs_inode_info *info = (struct netfs_inode_info *)(l + 1);
+
+                info->mode = inode->i_mode;
+                info->nlink = inode->i_nlink;
+                info->uid = inode->i_uid;
+                info->gid = inode->i_gid;
+                info->blocks = inode->i_blocks;
+                info->rdev = inode->i_rdev;
+                info->size = inode->i_size;
+                info->version = inode->i_version;
+
+                netfs_convert_inode_info(info);
+        }
+
+        netfs_trans_update(cmd, t, path_len + sizeof(struct netfs_lock) + isize);
+
+        return netfs_trans_finish(t, psb);
+
+err_out_free:
+        netfs_trans_free(t);
+err_out_exit:
+        printk("%s: err: %d.\n", __func__, err);
+        return err;
+}
+
+int pohmelfs_data_lock(struct pohmelfs_inode *pi, u64 start, u32 size, int type)
+{
+        struct pohmelfs_sb *psb = POHMELFS_SB(pi->vfs_inode.i_sb);
+        struct pohmelfs_mcache *m;
+        int err = -ENOMEM;
+        struct iattr iattr;
+        struct inode *inode = &pi->vfs_inode;
+
+        dprintk("%s: %p: ino: %llu, start: %llu, size: %u, "
+                        "type: %d, locked as: %d, owned: %d.\n",
+                        __func__, &pi->vfs_inode, pi->ino,
+                        start, size, type, pi->lock_type,
+                        !!test_bit(NETFS_INODE_OWNED, &pi->state));
+
+        if (!pohmelfs_need_lock(pi, type))
+                return 0;
+
+        m = pohmelfs_mcache_alloc(psb, start, size, NULL);
+        if (IS_ERR(m))
+                return PTR_ERR(m);
+
+        err = pohmelfs_send_lock_trans(pi, m->gen, start, size,
+                        type | POHMELFS_LOCK_GRAB);
+        if (err)
+                goto err_out_put;
+
+        err = wait_for_completion_timeout(&m->complete, psb->mcache_timeout);
+        if (err)
+                err = m->err;
+        else
+                err = -ETIMEDOUT;
+
+        if (err) {
+                printk("%s: %p: ino: %llu, mgen: %llu, start: %llu, size: %u, err: %d.\n",
+                        __func__, &pi->vfs_inode, pi->ino, m->gen, start, size, err);
+        }
+
+        if (err && (err != -ENOENT))
+                goto err_out_put;
+
+        if (!err) {
+                netfs_convert_inode_info(&m->info);
+
+                iattr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_SIZE | ATTR_ATIME;
+                iattr.ia_mode = m->info.mode;
+                iattr.ia_uid = m->info.uid;
+                iattr.ia_gid = m->info.gid;
+                iattr.ia_size = m->info.size;
+                iattr.ia_atime = CURRENT_TIME;
+
+                dprintk("%s: %p: ino: %llu, mgen: %llu, start: %llu, isize: %llu -> %llu.\n",
+                        __func__, &pi->vfs_inode, pi->ino, m->gen, start, inode->i_size, m->info.size);
+
+                err = pohmelfs_setattr_raw(inode, &iattr);
+                if (!err) {
+                        struct dentry *dentry = d_find_alias(inode);
+                        if (dentry) {
+                                fsnotify_change(dentry, iattr.ia_valid);
+                                dput(dentry);
+                        }
+                }
+        }
+
+        pi->lock_type = type;
+        set_bit(NETFS_INODE_OWNED, &pi->state);
+
+        pohmelfs_mcache_put(psb, m);
+
+        return 0;
+
+err_out_put:
+        pohmelfs_mcache_put(psb, m);
+        return err;
+}
+
+int pohmelfs_data_unlock(struct pohmelfs_inode *pi, u64 start, u32 size, int type)
+{
+        dprintk("%s: %p: ino: %llu, start: %llu, size: %u, type: %d.\n",
+                        __func__, &pi->vfs_inode, pi->ino, start, size, type);
+        pi->lock_type = 0;
+        clear_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state);
+        clear_bit(NETFS_INODE_OWNED, &pi->state);
+        return pohmelfs_send_lock_trans(pi, pi->ino, start, size, type);
+}