/* * 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; }