static int pohmelfs_crypto_finish(struct netfs_trans *t, struct pohmelfs_sb *psb, int err) { struct netfs_cmd *cmd = t->iovec.iov_base; netfs_convert_cmd(cmd); if (likely(!err)) err = netfs_trans_finish_send(t, psb); t->result = err; netfs_trans_put(t); return err; }
/* * 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 netfs_trans_send_pages(struct netfs_trans *t, struct netfs_state *st) { int err = 0; unsigned int i, attached_pages = t->attached_pages, ci; struct msghdr msg; struct page **pages = (t->eng)?t->eng->pages:t->pages; struct page *p; unsigned int size; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = MSG_WAITALL | MSG_MORE; ci = 0; for (i=0; i<t->page_num; ++i) { struct page *page = pages[ci]; struct netfs_cmd cmd; struct iovec io; p = t->pages[i]; if (!p) continue; size = page_private(p); io.iov_base = &cmd; io.iov_len = sizeof(struct netfs_cmd); cmd.cmd = NETFS_WRITE_PAGE; cmd.ext = 0; cmd.id = 0; cmd.size = size; cmd.start = p->index; cmd.start <<= PAGE_CACHE_SHIFT; cmd.csize = 0; cmd.cpad = 0; cmd.iv = pohmelfs_gen_iv(t); netfs_convert_cmd(&cmd); msg.msg_iov = &io; msg.msg_iovlen = 1; msg.msg_flags = MSG_WAITALL | MSG_MORE; err = kernel_sendmsg(st->socket, &msg, (struct kvec *)msg.msg_iov, 1, sizeof(struct netfs_cmd)); if (err <= 0) { printk("%s: %d/%d failed to send transaction header: t: %p, gen: %u, err: %d.\n", __func__, i, t->page_num, t, t->gen, err); if (err == 0) err = -ECONNRESET; goto err_out; } msg.msg_flags = MSG_WAITALL | (attached_pages == 1 ? 0 : MSG_MORE); err = kernel_sendpage(st->socket, page, 0, size, msg.msg_flags); if (err <= 0) { printk("%s: %d/%d failed to send transaction page: t: %p, gen: %u, size: %u, err: %d.\n", __func__, i, t->page_num, t, t->gen, size, err); if (err == 0) err = -ECONNRESET; goto err_out; } dprintk("%s: %d/%d sent t: %p, gen: %u, page: %p/%p, size: %u.\n", __func__, i, t->page_num, t, t->gen, page, p, size); err = 0; attached_pages--; if (!attached_pages) break; ci++; continue; err_out: printk("%s: t: %p, gen: %u, err: %d.\n", __func__, t, t->gen, err); netfs_state_exit(st); break; } 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; }