/*
* Sync inode to server.
* Returns zero in success and negative error value otherwise.
* It will gather path to root directory into structures containing
* creation mode, permissions and names, so that the whole path
* to given inode could be created using only single network command.
*/
int pohmelfs_write_inode_create(struct inode *inode, struct netfs_trans *trans)
{
struct pohmelfs_inode *pi = POHMELFS_I(inode);
int err = -ENOMEM, size;
struct netfs_cmd *cmd;
void *data;
int cur_len = netfs_trans_cur_len(trans);
if (unlikely(cur_len < 0))
return -ETOOSMALL;
cmd = netfs_trans_current(trans);
cur_len -= sizeof(struct netfs_cmd);
data = (void *)(cmd + 1);
err = pohmelfs_construct_path_string(pi, data, cur_len);
if (err < 0)
goto err_out_exit;
size = err;
cmd->start = i_size_read(inode);
cmd->cmd = NETFS_CREATE;
cmd->size = size;
cmd->id = pi->ino;
cmd->ext = inode->i_mode;
netfs_convert_cmd(cmd);
netfs_trans_update(cmd, trans, size);
return 0;
err_out_exit:
printk("%s: completed ino: %llu, err: %d.\n", __func__, pi->ino, err);
return err;
}
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;
}
