cregit-Linux how code gets into the kernel

Release 4.11 fs/cifs/smb2ops.c

Directory: fs/cifs
/*
 *  SMB2 version specific operations
 *
 *  Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
 *
 *  This library is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License v2 as published
 *  by the Free Software Foundation.
 *
 *  This library 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/pagemap.h>
#include <linux/vfs.h>
#include <linux/falloc.h>
#include <linux/scatterlist.h>
#include <linux/uuid.h>
#include <crypto/aead.h>
#include "cifsglob.h"
#include "smb2pdu.h"
#include "smb2proto.h"
#include "cifsproto.h"
#include "cifs_debug.h"
#include "cifs_unicode.h"
#include "smb2status.h"
#include "smb2glob.h"
#include "cifs_ioctl.h"


static int change_conf(struct TCP_Server_Info *server) { server->credits += server->echo_credits + server->oplock_credits; server->oplock_credits = server->echo_credits = 0; switch (server->credits) { case 0: return -1; case 1: server->echoes = false; server->oplocks = false; cifs_dbg(VFS, "disabling echoes and oplocks\n"); break; case 2: server->echoes = true; server->oplocks = false; server->echo_credits = 1; cifs_dbg(FYI, "disabling oplocks\n"); break; default: server->echoes = true; if (enable_oplocks) { server->oplocks = true; server->oplock_credits = 1; } else server->oplocks = false; server->echo_credits = 1; } server->credits -= server->echo_credits + server->oplock_credits; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky13286.27%133.33%
Steve French159.80%133.33%
Joe Perches63.92%133.33%
Total153100.00%3100.00%


static void smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add, const int optype) { int *val, rc = 0; spin_lock(&server->req_lock); val = server->ops->get_credits_field(server, optype); *val += add; if (*val > 65000) { *val = 65000; /* Don't get near 64K credits, avoid srv bugs */ printk_once(KERN_WARNING "server overflowed SMB3 credits\n"); } server->in_flight--; if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP) rc = change_conf(server); /* * Sometimes server returns 0 credits on oplock break ack - we need to * rebalance credits in this case. */ else if (server->in_flight > 0 && server->oplock_credits == 0 && server->oplocks) { if (server->credits > 1) { server->credits--; server->oplock_credits++; } } spin_unlock(&server->req_lock); wake_up(&server->request_q); if (rc) cifs_reconnect(server); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky14987.65%375.00%
Steve French2112.35%125.00%
Total170100.00%4100.00%


static void smb2_set_credits(struct TCP_Server_Info *server, const int val) { spin_lock(&server->req_lock); server->credits = val; spin_unlock(&server->req_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky37100.00%1100.00%
Total37100.00%1100.00%


static int * smb2_get_credits_field(struct TCP_Server_Info *server, const int optype) { switch (optype) { case CIFS_ECHO_OP: return &server->echo_credits; case CIFS_OBREAK_OP: return &server->oplock_credits; default: return &server->credits; } }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky47100.00%1100.00%
Total47100.00%1100.00%


static unsigned int smb2_get_credits(struct mid_q_entry *mid) { struct smb2_sync_hdr *shdr = get_sync_hdr(mid->resp_buf); return le16_to_cpu(shdr->CreditRequest); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky32100.00%2100.00%
Total32100.00%2100.00%


static int smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size, unsigned int *num, unsigned int *credits) { int rc = 0; unsigned int scredits; spin_lock(&server->req_lock); while (1) { if (server->credits <= 0) { spin_unlock(&server->req_lock); cifs_num_waiters_inc(server); rc = wait_event_killable(server->request_q, has_credits(server, &server->credits)); cifs_num_waiters_dec(server); if (rc) return rc; spin_lock(&server->req_lock); } else { if (server->tcpStatus == CifsExiting) { spin_unlock(&server->req_lock); return -ENOENT; } scredits = server->credits; /* can deadlock with reopen */ if (scredits == 1) { *num = SMB2_MAX_BUFFER_SIZE; *credits = 0; break; } /* leave one credit for a possible reopen */ scredits--; *num = min_t(unsigned int, size, scredits * SMB2_MAX_BUFFER_SIZE); *credits = DIV_ROUND_UP(*num, SMB2_MAX_BUFFER_SIZE); server->credits -= *credits; server->in_flight++; break; } } spin_unlock(&server->req_lock); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky212100.00%2100.00%
Total212100.00%2100.00%


static __u64 smb2_get_next_mid(struct TCP_Server_Info *server) { __u64 mid; /* for SMB2 we need the current value */ spin_lock(&GlobalMid_Lock); mid = server->CurrentMid++; spin_unlock(&GlobalMid_Lock); return mid; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky37100.00%2100.00%
Total37100.00%2100.00%


static struct mid_q_entry * smb2_find_mid(struct TCP_Server_Info *server, char *buf) { struct mid_q_entry *mid; struct smb2_sync_hdr *shdr = get_sync_hdr(buf); __u64 wire_mid = le64_to_cpu(shdr->MessageId); if (shdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM) { cifs_dbg(VFS, "encrypted frame parsing not supported yet"); return NULL; } spin_lock(&GlobalMid_Lock); list_for_each_entry(mid, &server->pending_mid_q, qhead) { if ((mid->mid == wire_mid) && (mid->mid_state == MID_REQUEST_SUBMITTED) && (mid->command == shdr->Command)) { spin_unlock(&GlobalMid_Lock); return mid; } } spin_unlock(&GlobalMid_Lock); return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky9776.98%250.00%
Steve French1915.08%125.00%
Sachin S. Prabhu107.94%125.00%
Total126100.00%4100.00%


static void smb2_dump_detail(void *buf) { #ifdef CONFIG_CIFS_DEBUG2 struct smb2_sync_hdr *shdr = get_sync_hdr(buf); cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n", shdr->Command, shdr->Status, shdr->Flags, shdr->MessageId, shdr->ProcessId); cifs_dbg(VFS, "smb buf %p len %u\n", buf, smb2_calc_size(buf)); #endif }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky6090.91%266.67%
Joe Perches69.09%133.33%
Total66100.00%3100.00%


static bool smb2_need_neg(struct TCP_Server_Info *server) { return server->max_read == 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky18100.00%1100.00%
Total18100.00%1100.00%


static int smb2_negotiate(const unsigned int xid, struct cifs_ses *ses) { int rc; ses->server->CurrentMid = 0; rc = SMB2_negotiate(xid, ses); /* BB we probably don't need to retry with modern servers */ if (rc == -EAGAIN) rc = -EHOSTDOWN; return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky52100.00%1100.00%
Total52100.00%1100.00%


static unsigned int smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info) { struct TCP_Server_Info *server = tcon->ses->server; unsigned int wsize; /* start with specified wsize, or default */ wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE; wsize = min_t(unsigned int, wsize, server->max_write); if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU)) wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE); return wsize; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky81100.00%4100.00%
Total81100.00%4100.00%


static unsigned int smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info) { struct TCP_Server_Info *server = tcon->ses->server; unsigned int rsize; /* start with specified rsize, or default */ rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE; rsize = min_t(unsigned int, rsize, server->max_read); if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU)) rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE); return rsize; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky81100.00%3100.00%
Total81100.00%3100.00%

#ifdef CONFIG_CIFS_STATS2
static int SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon) { int rc; unsigned int ret_data_len = 0; struct network_interface_info_ioctl_rsp *out_buf; rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, FSCTL_QUERY_NETWORK_INTERFACE_INFO, true /* is_fsctl */, false /* use_ipc */, NULL /* no data input */, 0 /* no data input */, (char **)&out_buf, &ret_data_len); if (rc != 0) cifs_dbg(VFS, "error %d on ioctl to get interface list\n", rc); else if (ret_data_len < sizeof(struct network_interface_info_ioctl_rsp)) { cifs_dbg(VFS, "server returned bad net interface info buf\n"); rc = -EINVAL; } else { /* Dump info on first interface */ cifs_dbg(FYI, "Adapter Capability 0x%x\t", le32_to_cpu(out_buf->Capability)); cifs_dbg(FYI, "Link Speed %lld\n", le64_to_cpu(out_buf->LinkSpeed)); } kfree(out_buf); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French14597.97%375.00%
Aurelien Aptel32.03%125.00%
Total148100.00%4100.00%

#endif /* STATS2 */
static void smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon) { int rc; __le16 srch_path = 0; /* Null - open root of share */ u8 oplock = SMB2_OPLOCK_LEVEL_NONE; struct cifs_open_parms oparms; struct cifs_fid fid; oparms.tcon = tcon; oparms.desired_access = FILE_READ_ATTRIBUTES; oparms.disposition = FILE_OPEN; oparms.create_options = 0; oparms.fid = &fid; oparms.reconnect = false; rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL); if (rc) return; #ifdef CONFIG_CIFS_STATS2 SMB3_request_interfaces(xid, tcon); #endif /* STATS2 */ SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, FS_ATTRIBUTE_INFORMATION); SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, FS_DEVICE_INFORMATION); SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, FS_SECTOR_SIZE_INFORMATION); /* SMB3 specific */ SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); return; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French18099.45%375.00%
Pavel Shilovsky10.55%125.00%
Total181100.00%4100.00%


static void smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon) { int rc; __le16 srch_path = 0; /* Null - open root of share */ u8 oplock = SMB2_OPLOCK_LEVEL_NONE; struct cifs_open_parms oparms; struct cifs_fid fid; oparms.tcon = tcon; oparms.desired_access = FILE_READ_ATTRIBUTES; oparms.disposition = FILE_OPEN; oparms.create_options = 0; oparms.fid = &fid; oparms.reconnect = false; rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL); if (rc) return; SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, FS_ATTRIBUTE_INFORMATION); SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, FS_DEVICE_INFORMATION); SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); return; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French150100.00%3100.00%
Total150100.00%3100.00%


static int smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const char *full_path) { int rc; __le16 *utf16_path; __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; struct cifs_open_parms oparms; struct cifs_fid fid; utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb); if (!utf16_path) return -ENOMEM; oparms.tcon = tcon; oparms.desired_access = FILE_READ_ATTRIBUTES; oparms.disposition = FILE_OPEN; oparms.create_options = 0; oparms.fid = &fid; oparms.reconnect = false; rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL); if (rc) { kfree(utf16_path); return rc; } rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); kfree(utf16_path); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky15899.37%685.71%
Steve French10.63%114.29%
Total159100.00%7100.00%


static int smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const char *full_path, u64 *uniqueid, FILE_ALL_INFO *data) { *uniqueid = le64_to_cpu(data->IndexNumber); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky47100.00%1100.00%
Total47100.00%1100.00%


static int smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *fid, FILE_ALL_INFO *data) { int rc; struct smb2_file_all_info *smb2_data; smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2, GFP_KERNEL); if (smb2_data == NULL) return -ENOMEM; rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid, smb2_data); if (!rc) move_smb2_info_to_cifs(data, smb2_data); kfree(smb2_data); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky99100.00%3100.00%
Total99100.00%3100.00%


static bool smb2_can_echo(struct TCP_Server_Info *server) { return server->echoes; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky16100.00%2100.00%
Total16100.00%2100.00%


static void smb2_clear_stats(struct cifs_tcon *tcon) { #ifdef CONFIG_CIFS_STATS int i; for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) { atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0); atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0); } #endif }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky68100.00%1100.00%
Total68100.00%1100.00%


static void smb2_dump_share_caps(struct seq_file *m, struct cifs_tcon *tcon) { seq_puts(m, "\n\tShare Capabilities:"); if (tcon->capabilities & SMB2_SHARE_CAP_DFS) seq_puts(m, " DFS,"); if (tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY) seq_puts(m, " CONTINUOUS AVAILABILITY,"); if (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT) seq_puts(m, " SCALEOUT,"); if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) seq_puts(m, " CLUSTER,"); if (tcon->capabilities & SMB2_SHARE_CAP_ASYMMETRIC) seq_puts(m, " ASYMMETRIC,"); if (tcon->capabilities == 0) seq_puts(m, " None"); if (tcon->ss_flags & SSINFO_FLAGS_ALIGNED_DEVICE) seq_puts(m, " Aligned,"); if (tcon->ss_flags & SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE) seq_puts(m, " Partition Aligned,"); if (tcon->ss_flags & SSINFO_FLAGS_NO_SEEK_PENALTY) seq_puts(m, " SSD,"); if (tcon->ss_flags & SSINFO_FLAGS_TRIM_ENABLED) seq_puts(m, " TRIM-support,"); seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags); if (tcon->perf_sector_size) seq_printf(m, "\tOptimal sector size: 0x%x", tcon->perf_sector_size); }

Contributors

PersonTokensPropCommitsCommitProp
Steve French19999.00%266.67%
Pavel Shilovsky21.00%133.33%
Total201100.00%3100.00%


static void smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon) { #ifdef CONFIG_CIFS_STATS atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent; atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed; seq_printf(m, "\nNegotiates: %d sent %d failed", atomic_read(&sent[SMB2_NEGOTIATE_HE]), atomic_read(&failed[SMB2_NEGOTIATE_HE])); seq_printf(m, "\nSessionSetups: %d sent %d failed", atomic_read(&sent[SMB2_SESSION_SETUP_HE]), atomic_read(&failed[SMB2_SESSION_SETUP_HE])); seq_printf(m, "\nLogoffs: %d sent %d failed", atomic_read(&sent[SMB2_LOGOFF_HE]), atomic_read(&failed[SMB2_LOGOFF_HE])); seq_printf(m, "\nTreeConnects: %d sent %d failed", atomic_read(&sent[SMB2_TREE_CONNECT_HE]), atomic_read(&failed[SMB2_TREE_CONNECT_HE])); seq_printf(m, "\nTreeDisconnects: %d sent %d failed", atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]), atomic_read(&failed[SMB2_TREE_DISCONNECT_HE])); seq_printf(m, "\nCreates: %d sent %d failed", atomic_read(&sent[SMB2_CREATE_HE]), atomic_read(&failed[SMB2_CREATE_HE])); seq_printf(m, "\nCloses: %d sent %d failed", atomic_read(&sent[SMB2_CLOSE_HE]), atomic_read(&failed[SMB2_CLOSE_HE])); seq_printf(m, "\nFlushes: %d sent %d failed", atomic_read(&sent[SMB2_FLUSH_HE]), atomic_read(&failed[SMB2_FLUSH_HE])); seq_printf(m, "\nReads: %d sent %d failed", atomic_read(&sent[SMB2_READ_HE]), atomic_read(&failed[SMB2_READ_HE])); seq_printf(m, "\nWrites: %d sent %d failed", atomic_read(&sent[SMB2_WRITE_HE]), atomic_read(&failed[SMB2_WRITE_HE])); seq_printf(m, "\nLocks: %d sent %d failed", atomic_read(&sent[SMB2_LOCK_HE]), atomic_read(&failed[SMB2_LOCK_HE])); seq_printf(m, "\nIOCTLs: %d sent %d failed", atomic_read(&sent[SMB2_IOCTL_HE]), atomic_read(&failed[SMB2_IOCTL_HE])); seq_printf(m, "\nCancels: %d sent %d failed", atomic_read(&sent[SMB2_CANCEL_HE]), atomic_read(&failed[SMB2_CANCEL_HE])); seq_printf(m, "\nEchos: %d sent %d failed", atomic_read(&sent[SMB2_ECHO_HE]), atomic_read(&failed[SMB2_ECHO_HE])); seq_printf(m, "\nQueryDirectories: %d sent %d failed", atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]), atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE])); seq_printf(m, "\nChangeNotifies: %d sent %d failed", atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]), atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE])); seq_printf(m, "\nQueryInfos: %d sent %d failed", atomic_read(&sent[SMB2_QUERY_INFO_HE]), atomic_read(&failed[SMB2_QUERY_INFO_HE])); seq_printf(m, "\nSetInfos: %d sent %d failed", atomic_read(&sent[SMB2_SET_INFO_HE]), atomic_read(&failed[SMB2_SET_INFO_HE])); seq_printf(m, "\nOplockBreaks: %d sent %d failed", atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]), atomic_read(&failed[SMB2_OPLOCK_BREAK_HE])); #endif }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky51899.62%150.00%
Steve French20.38%150.00%
Total520100.00%2100.00%


static void smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock) { struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; cfile->fid.persistent_fid = fid->persistent_fid; cfile->fid.volatile_fid = fid->volatile_fid; server->ops->set_oplock_level(cinode, oplock, fid->epoch, &fid->purge_cache); cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode); memcpy(cfile->fid.create_guid, fid->create_guid, 16); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky9684.21%675.00%
Aurelien Aptel1513.16%112.50%
David Howells32.63%112.50%
Total114100.00%8100.00%


static void smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *fid) { SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky36100.00%2100.00%
Total36100.00%2100.00%


static int SMB2_request_res_key(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid, u64 volatile_fid, struct copychunk_ioctl *pcchunk) { int rc; unsigned int ret_data_len; struct resume_key_req *res_key; rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid, FSCTL_SRV_REQUEST_RESUME_KEY, true /* is_fsctl */, false /* use_ipc */, NULL, 0 /* no input */, (char **)&res_key, &ret_data_len); if (rc) { cifs_dbg(VFS, "refcpy ioctl error %d getting resume key\n", rc); goto req_res_key_exit; } if (ret_data_len < sizeof(struct resume_key_req)) { cifs_dbg(VFS, "Invalid refcopy resume key length\n"); rc = -EINVAL; goto req_res_key_exit; } memcpy(pcchunk->SourceKey, res_key->ResumeKey, COPY_CHUNK_RES_KEY_SIZE); req_res_key_exit: kfree(res_key); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French13996.53%133.33%
Aurelien Aptel32.08%133.33%
Pavel Shilovsky21.39%133.33%
Total144100.00%3100.00%


static ssize_t smb2_copychunk_range(const unsigned int xid, struct cifsFileInfo *srcfile, struct cifsFileInfo *trgtfile, u64 src_off, u64 len, u64 dest_off) { int rc; unsigned int ret_data_len; struct copychunk_ioctl *pcchunk; struct copychunk_ioctl_rsp *retbuf = NULL; struct cifs_tcon *tcon; int chunks_copied = 0; bool chunk_sizes_updated = false; ssize_t bytes_written, total_bytes_written = 0; pcchunk = kmalloc(sizeof(struct copychunk_ioctl), GFP_KERNEL); if (pcchunk == NULL) return -ENOMEM; cifs_dbg(FYI, "in smb2_copychunk_range - about to call request res key\n"); /* Request a key from the server to identify the source of the copy */ rc = SMB2_request_res_key(xid, tlink_tcon(srcfile->tlink), srcfile->fid.persistent_fid, srcfile->fid.volatile_fid, pcchunk); /* Note: request_res_key sets res_key null only if rc !=0 */ if (rc) goto cchunk_out; /* For now array only one chunk long, will make more flexible later */ pcchunk->ChunkCount = cpu_to_le32(1); pcchunk->Reserved = 0; pcchunk->Reserved2 = 0; tcon = tlink_tcon(trgtfile->tlink); while (len > 0) { pcchunk->SourceOffset = cpu_to_le64(src_off); pcchunk->TargetOffset = cpu_to_le64(dest_off); pcchunk->Length = cpu_to_le32(min_t(u32, len, tcon->max_bytes_chunk)); /* Request server copy to target from src identified by key */ rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid, trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE, true /* is_fsctl */, false /* use_ipc */, (char *)pcchunk, sizeof(struct copychunk_ioctl), (char **)&retbuf, &ret_data_len); if (rc == 0) { if (ret_data_len != sizeof(struct copychunk_ioctl_rsp)) { cifs_dbg(VFS, "invalid cchunk response size\n"); rc = -EIO; goto cchunk_out; } if (retbuf->TotalBytesWritten == 0) { cifs_dbg(FYI, "no bytes copied\n"); rc = -EIO; goto cchunk_out; } /* * Check if server claimed to write more than we asked */ if (le32_to_cpu(retbuf->TotalBytesWritten) > le32_to_cpu(pcchunk->Length)) { cifs_dbg(VFS, "invalid copy chunk response\n"); rc = -EIO; goto cchunk_out; } if (le32_to_cpu(retbuf->ChunksWritten) != 1) { cifs_dbg(VFS, "invalid num chunks written\n"); rc = -EIO; goto cchunk_out; } chunks_copied++; bytes_written = le32_to_cpu(retbuf->TotalBytesWritten); src_off += bytes_written; dest_off += bytes_written; len -= bytes_written; total_bytes_written += bytes_written; cifs_dbg(FYI, "Chunks %d PartialChunk %d Total %zu\n", le32_to_cpu(retbuf->ChunksWritten), le32_to_cpu(retbuf->ChunkBytesWritten), bytes_written); } else if (rc == -EINVAL) { if (ret_data_len != sizeof(struct copychunk_ioctl_rsp)) goto cchunk_out; cifs_dbg(FYI, "MaxChunks %d BytesChunk %d MaxCopy %d\n", le32_to_cpu(retbuf->ChunksWritten), le32_to_cpu(retbuf->ChunkBytesWritten), le32_to_cpu(retbuf->TotalBytesWritten)); /* * Check if this is the first request using these sizes, * (ie check if copy succeed once with original sizes * and check if the server gave us different sizes after * we already updated max sizes on previous request). * if not then why is the server returning an error now */ if ((chunks_copied != 0) || chunk_sizes_updated) goto cchunk_out; /* Check that server is not asking us to grow size */ if (le32_to_cpu(retbuf->ChunkBytesWritten) < tcon->max_bytes_chunk) tcon->max_bytes_chunk = le32_to_cpu(retbuf->ChunkBytesWritten); else goto cchunk_out; /* server gave us bogus size */ /* No need to change MaxChunks since already set to 1 */ chunk_sizes_updated = true; } else goto cchunk_out; } cchunk_out: kfree(pcchunk); kfree(retbuf); if (rc) return rc; else return total_bytes_written; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French52692.93%337.50%
Sachin S. Prabhu366.36%337.50%
Aurelien Aptel30.53%112.50%
Fabian Frederick10.18%112.50%
Total566100.00%8100.00%


static int smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *fid) { return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky3594.59%150.00%
Steve French25.41%150.00%
Total37100.00%2100.00%


static unsigned int smb2_read_data_offset(char *buf) { struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf; return rsp->DataOffset; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky28100.00%1100.00%
Total28100.00%1100.00%


static unsigned int smb2_read_data_length(char *buf) { struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf; return le32_to_cpu(rsp->DataLength); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky31100.00%1100.00%
Total31100.00%1100.00%


static int smb2_sync_read(const unsigned int xid, struct cifs_fid *pfid, struct cifs_io_parms *parms, unsigned int *bytes_read, char **buf, int *buf_type) { parms->persistent_fid = pfid->persistent_fid; parms->volatile_fid = pfid->volatile_fid; return SMB2_read(xid, parms, bytes_read, buf, buf_type); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky6193.85%150.00%
Steve French46.15%150.00%
Total65100.00%2100.00%


static int smb2_sync_write(const unsigned int xid, struct cifs_fid *pfid, struct cifs_io_parms *parms, unsigned int *written, struct kvec *iov, unsigned long nr_segs) { parms->persistent_fid = pfid->persistent_fid; parms->volatile_fid = pfid->volatile_fid; return SMB2_write(xid, parms, written, iov, nr_segs); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky6193.85%150.00%
Steve French46.15%150.00%
Total65100.00%2100.00%

/* Set or clear the SPARSE_FILE attribute based on value passed in setsparse */
static bool smb2_set_sparse(const unsigned int xid, struct cifs_tcon *tcon, struct cifsFileInfo *cfile, struct inode *inode, __u8 setsparse) { struct cifsInodeInfo *cifsi; int rc; cifsi = CIFS_I(inode); /* if file already sparse don't bother setting sparse again */ if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && setsparse) return true; /* already sparse */ if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && !setsparse) return true; /* already not sparse */ /* * Can't check for sparse support on share the usual way via the * FS attribute info (FILE_SUPPORTS_SPARSE_FILES) on the share * since Samba server doesn't set the flag on the share, yet * supports the set sparse FSCTL and returns sparse correctly * in the file attributes. If we fail setting sparse though we * mark that server does not support sparse files for this share * to avoid repeatedly sending the unsupported fsctl to server * if the file is repeatedly extended. */ if (tcon->broken_sparse_sup) return false; rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, FSCTL_SET_SPARSE, true /* is_fctl */, false /* use_ipc */, &setsparse, 1, NULL, NULL); if (rc) { tcon->broken_sparse_sup = true; cifs_dbg(FYI, "set sparse rc = %d\n", rc); return false; } if (setsparse) cifsi->cifsAttrs |= FILE_ATTRIBUTE_SPARSE_FILE; else cifsi->cifsAttrs &= (~FILE_ATTRIBUTE_SPARSE_FILE); return true; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French15488.51%250.00%
Pavel Shilovsky179.77%125.00%
Aurelien Aptel31.72%125.00%
Total174100.00%4100.00%


static int smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon, struct cifsFileInfo *cfile, __u64 size, bool set_alloc) { __le64 eof = cpu_to_le64(size); struct inode *inode; /* * If extending file more than one page make sparse. Many Linux fs * make files sparse by default when extending via ftruncate */ inode = d_inode(cfile->dentry); if (!set_alloc && (size > inode->i_size + 8192)) { __u8 set_sparse = 1; /* whether set sparse succeeds or not, extend the file */ smb2_set_sparse(xid, tcon, cfile, inode, set_sparse); } return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, cfile->pid, &eof, false); }

Contributors

PersonTokensPropCommitsCommitProp
Steve French8473.04%360.00%
Pavel Shilovsky2824.35%120.00%
David Howells32.61%120.00%
Total115100.00%5100.00%


static int smb2_duplicate_extents(const unsigned int xid, struct cifsFileInfo *srcfile, struct cifsFileInfo *trgtfile, u64 src_off, u64 len, u64 dest_off) { int rc; unsigned int ret_data_len; struct duplicate_extents_to_file dup_ext_buf; struct cifs_tcon *tcon = tlink_tcon(trgtfile->tlink); /* server fileays advertise duplicate extent support with this flag */ if ((le32_to_cpu(tcon->fsAttrInfo.Attributes) & FILE_SUPPORTS_BLOCK_REFCOUNTING) == 0) return -EOPNOTSUPP; dup_ext_buf.VolatileFileHandle = srcfile->fid.volatile_fid; dup_ext_buf.PersistentFileHandle = srcfile->fid.persistent_fid; dup_ext_buf.SourceFileOffset = cpu_to_le64(src_off); dup_ext_buf.TargetFileOffset = cpu_to_le64(dest_off); dup_ext_buf.ByteCount = cpu_to_le64(len); cifs_dbg(FYI, "duplicate extents: src off %lld dst off %lld len %lld", src_off, dest_off, len); rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false); if (rc) goto duplicate_extents_out; rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid, trgtfile->fid.volatile_fid, FSCTL_DUPLICATE_EXTENTS_TO_FILE, true /* is_fsctl */, false /* use_ipc */, (char *)&dup_ext_buf, sizeof(struct duplicate_extents_to_file), NULL, &ret_data_len); if (ret_data_len > 0) cifs_dbg(FYI, "non-zero response length in duplicate extents"); duplicate_extents_out: return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French22198.66%266.67%
Aurelien Aptel31.34%133.33%
Total224100.00%3100.00%


static int smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon, struct cifsFileInfo *cfile) { return SMB2_set_compression(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid); }

Contributors

PersonTokensPropCommitsCommitProp
Steve French3995.12%150.00%
Pavel Shilovsky24.88%150.00%
Total41100.00%2100.00%


static int smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon, struct cifsFileInfo *cfile) { struct fsctl_set_integrity_information_req integr_info; unsigned int ret_data_len; integr_info.ChecksumAlgorithm = cpu_to_le16(CHECKSUM_TYPE_UNCHANGED); integr_info.Flags = 0; integr_info.Reserved = 0; return SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, FSCTL_SET_INTEGRITY_INFORMATION, true /* is_fsctl */, false /* use_ipc */, (char *)&integr_info, sizeof(struct fsctl_set_integrity_information_req), NULL, &ret_data_len); }

Contributors

PersonTokensPropCommitsCommitProp
Steve French9396.88%375.00%
Aurelien Aptel33.12%125.00%
Total96100.00%4100.00%


static int smb3_enum_snapshots(const unsigned int xid, struct cifs_tcon *tcon, struct cifsFileInfo *cfile, void __user *ioc_buf) { char *retbuf = NULL; unsigned int ret_data_len = 0; int rc; struct smb_snapshot_array snapshot_in; rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, FSCTL_SRV_ENUMERATE_SNAPSHOTS, true /* is_fsctl */, false /* use_ipc */, NULL, 0 /* no input data */, (char **)&retbuf, &ret_data_len); cifs_dbg(FYI, "enum snaphots ioctl returned %d and ret buflen is %d\n", rc, ret_data_len); if (rc) return rc; if (ret_data_len && (ioc_buf != NULL) && (retbuf != NULL)) { /* Fixup buffer */ if (copy_from_user(&snapshot_in, ioc_buf, sizeof(struct smb_snapshot_array))) { rc = -EFAULT; kfree(retbuf); return rc; } if (snapshot_in.snapshot_array_size < sizeof(struct smb_snapshot_array)) { rc = -ERANGE; return rc; } if (ret_data_len > snapshot_in.snapshot_array_size) ret_data_len = snapshot_in.snapshot_array_size; if (copy_to_user(ioc_buf, retbuf, ret_data_len)) rc = -EFAULT; } kfree(retbuf); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French21598.62%266.67%
Aurelien Aptel31.38%133.33%
Total218100.00%3100.00%


static int smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon, const char *path, struct cifs_sb_info *cifs_sb, struct cifs_fid *fid, __u16 search_flags, struct cifs_search_info *srch_inf) { __le16 *utf16_path; int rc; __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; struct cifs_open_parms oparms; utf16_path = cifs_convert_path_to_utf16(path, cifs_sb); if (!utf16_path) return -ENOMEM; oparms.tcon = tcon; oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA; oparms.disposition = FILE_OPEN; oparms.create_options = 0; oparms.fid = fid; oparms.reconnect = false; rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL); kfree(utf16_path); if (rc) { cifs_dbg(VFS, "open dir failed\n"); return rc; } srch_inf->entries_in_buffer = 0; srch_inf->index_of_last_entry = 0; rc = SMB2_query_directory(xid, tcon, fid->persistent_fid, fid->volatile_fid, 0, srch_inf); if (rc) { cifs_dbg(VFS, "query directory failed\n"); SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid); } return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky20796.28%571.43%
Joe Perches62.79%114.29%
Steve French20.93%114.29%
Total215100.00%7100.00%


static int smb2_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *fid, __u16 search_flags, struct cifs_search_info *srch_inf) { return SMB2_query_directory(xid, tcon, fid->persistent_fid, fid->volatile_fid, 0, srch_inf); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky49100.00%1100.00%
Total49100.00%1100.00%


static int smb2_close_dir(const unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *fid) { return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky37100.00%1100.00%
Total37100.00%1100.00%

/* * If we negotiate SMB2 protocol and get STATUS_PENDING - update * the number of credits and return true. Otherwise - return false. */
static bool smb2_is_status_pending(char *buf, struct TCP_Server_Info *server, int length) { struct smb2_sync_hdr *shdr = get_sync_hdr(buf); if (shdr->Status != STATUS_PENDING) return false; if (!length) { spin_lock(&server->req_lock); server->credits += le16_to_cpu(shdr->CreditRequest); spin_unlock(&server->req_lock); wake_up(&server->request_q); } return true; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky84100.00%2100.00%
Total84100.00%2100.00%


static int smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid, struct cifsInodeInfo *cinode) { if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING) return SMB2_lease_break(0, tcon, cinode->lease_key, smb2_get_lease_state(cinode)); return SMB2_oplock_break(0, tcon, fid->persistent_fid, fid->volatile_fid, CIFS_CACHE_READ(cinode) ? 1 : 0); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky75100.00%3100.00%
Total75100.00%3100.00%


static int smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon, struct kstatfs *buf) { int rc; __le16 srch_path = 0; /* Null - open root of share */ u8 oplock = SMB2_OPLOCK_LEVEL_NONE; struct cifs_open_parms oparms; struct cifs_fid fid; oparms.tcon = tcon; oparms.desired_access = FILE_READ_ATTRIBUTES; oparms.disposition = FILE_OPEN; oparms.create_options = 0; oparms.fid = &fid; oparms.reconnect = false; rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL); if (rc) return rc; buf->f_type = SMB2_MAGIC_NUMBER; rc = SMB2_QFS_info(xid, tcon, fid.persistent_fid, fid.volatile_fid, buf); SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky150100.00%4100.00%
Total150100.00%4100.00%


static bool smb2_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2) { return ob1->fid.persistent_fid == ob2->fid.persistent_fid && ob1->fid.volatile_fid == ob2->fid.volatile_fid; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky41100.00%1100.00%
Total41100.00%1100.00%


static int smb2_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset, __u64 length, __u32 type, int lock, int unlock, bool wait) { if (unlock && !lock) type = SMB2_LOCKFLAG_UNLOCK; return SMB2_lock(xid, tlink_tcon(cfile->tlink), cfile->fid.persistent_fid, cfile->fid.volatile_fid, current->tgid, length, offset, type, wait); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky82100.00%1100.00%
Total82100.00%1100.00%


static void smb2_get_lease_key(struct inode *inode, struct cifs_fid *fid) { memcpy(fid->lease_key, CIFS_I(inode)->lease_key, SMB2_LEASE_KEY_SIZE); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky32100.00%1100.00%
Total32100.00%1100.00%


static void smb2_set_lease_key(struct inode *inode, struct cifs_fid *fid) { memcpy(CIFS_I(inode)->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky32100.00%1100.00%
Total32100.00%1100.00%


static void smb2_new_lease_key(struct cifs_fid *fid) { generate_random_uuid(fid->lease_key); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky1794.44%150.00%
Steve French15.56%150.00%
Total18100.00%2100.00%


static int smb2_get_dfs_refer(const unsigned int xid, struct cifs_ses *ses, const char *search_name, struct dfs_info3_param **target_nodes, unsigned int *num_of_nodes, const struct nls_table *nls_codepage, int remap) { int rc; __le16 *utf16_path = NULL; int utf16_path_len = 0; struct cifs_tcon *tcon; struct fsctl_get_dfs_referral_req *dfs_req = NULL; struct get_dfs_referral_rsp *dfs_rsp = NULL; u32 dfs_req_size = 0, dfs_rsp_size = 0; cifs_dbg(FYI, "smb2_get_dfs_refer path <%s>\n", search_name); /* * Use any tcon from the current session. Here, the first one. */ spin_lock(&cifs_tcp_ses_lock); tcon = list_first_entry_or_null(&ses->tcon_list, struct cifs_tcon, tcon_list); if (tcon) tcon->tc_count++; spin_unlock(&cifs_tcp_ses_lock); if (!tcon) { cifs_dbg(VFS, "session %p has no tcon available for a dfs referral request\n", ses); rc = -ENOTCONN; goto out; } utf16_path = cifs_strndup_to_utf16(search_name, PATH_MAX, &utf16_path_len, nls_codepage, remap); if (!utf16_path) { rc = -ENOMEM; goto out; } dfs_req_size = sizeof(*dfs_req) + utf16_path_len; dfs_req = kzalloc(dfs_req_size, GFP_KERNEL); if (!dfs_req) { rc = -ENOMEM; goto out; } /* Highest DFS referral version understood */ dfs_req->MaxReferralLevel = DFS_VERSION; /* Path to resolve in an UTF-16 null-terminated string */ memcpy(dfs_req->RequestFileName, utf16_path, utf16_path_len); do { /* try first with IPC */ rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, FSCTL_DFS_GET_REFERRALS, true /* is_fsctl */, true /* use_ipc */, (char *)dfs_req, dfs_req_size, (char **)&dfs_rsp, &dfs_rsp_size); if (rc == -ENOTCONN) { /* try with normal tcon */ rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, FSCTL_DFS_GET_REFERRALS, true /* is_fsctl */, false /*use_ipc*/, (char *)dfs_req, dfs_req_size, (char **)&dfs_rsp, &dfs_rsp_size); } } while (rc == -EAGAIN); if (rc) { cifs_dbg(VFS, "ioctl error in smb2_get_dfs_refer rc=%d\n", rc); goto out; } rc = parse_dfs_referrals(dfs_rsp, dfs_rsp_size, num_of_nodes, target_nodes, nls_codepage, remap, search_name, true /* is_unicode */); if (rc) { cifs_dbg(VFS, "parse error in smb2_get_dfs_refer rc=%d\n", rc); goto out; } out: if (tcon) { spin_lock(&cifs_tcp_ses_lock); tcon->tc_count--; spin_unlock(&cifs_tcp_ses_lock); } kfree(utf16_path); kfree(dfs_req); kfree(dfs_rsp); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Aurelien Aptel440100.00%1100.00%
Total440100.00%1100.00%

#define SMB2_SYMLINK_STRUCT_SIZE \ (sizeof(struct smb2_err_rsp) - 1 + sizeof(struct smb2_symlink_err_rsp))
static int smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, const char *full_path, char **target_path, struct cifs_sb_info *cifs_sb) { int rc; __le16 *utf16_path; __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; struct cifs_open_parms oparms; struct cifs_fid fid; struct smb2_err_rsp *err_buf = NULL; struct smb2_symlink_err_rsp *symlink; unsigned int sub_len; unsigned int sub_offset; unsigned int print_len; unsigned int print_offset; cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path); utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb); if (!utf16_path) return -ENOMEM; oparms.tcon = tcon; oparms.desired_access = FILE_READ_ATTRIBUTES; oparms.disposition = FILE_OPEN; oparms.create_options = 0; oparms.fid = &fid; oparms.reconnect = false; rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_buf); if (!rc || !err_buf) { kfree(utf16_path); return -ENOENT; } if (le32_to_cpu(err_buf->ByteCount) < sizeof(struct smb2_symlink_err_rsp) || get_rfc1002_length(err_buf) + 4 < SMB2_SYMLINK_STRUCT_SIZE) { kfree(utf16_path); return -ENOENT; } /* open must fail on symlink - reset rc */ rc = 0; symlink = (struct smb2_symlink_err_rsp *)err_buf->ErrorData; sub_len = le16_to_cpu(symlink->SubstituteNameLength); sub_offset = le16_to_cpu(symlink->SubstituteNameOffset); print_len = le16_to_cpu(symlink->PrintNameLength); print_offset = le16_to_cpu(symlink->PrintNameOffset); if (get_rfc1002_length(err_buf) + 4 < SMB2_SYMLINK_STRUCT_SIZE + sub_offset + sub_len) { kfree(utf16_path); return -ENOENT; } if (get_rfc1002_length(err_buf) + 4 < SMB2_SYMLINK_STRUCT_SIZE + print_offset + print_len) { kfree(utf16_path); return -ENOENT; } *target_path = cifs_strndup_from_utf16( (char *)symlink->PathBuffer + sub_offset, sub_len, true, cifs_sb->local_nls); if (!(*target_path)) { kfree(utf16_path); return -ENOMEM; } convert_delimiter(*target_path, '/'); cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path); kfree(utf16_path); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky394100.00%2100.00%
Total394100.00%2100.00%


static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon, loff_t offset, loff_t len, bool keep_size) { struct inode *inode; struct cifsInodeInfo *cifsi; struct cifsFileInfo *cfile = file->private_data; struct file_zero_data_information fsctl_buf; long rc; unsigned int xid; xid = get_xid(); inode = d_inode(cfile->dentry); cifsi = CIFS_I(inode); /* if file not oplocked can't be sure whether asking to extend size */ if (!CIFS_CACHE_READ(cifsi)) if (keep_size == false) return -EOPNOTSUPP; /* * Must check if file sparse since fallocate -z (zero range) assumes * non-sparse allocation */ if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)) return -EOPNOTSUPP; /* * need to make sure we are not asked to extend the file since the SMB3 * fsctl does not change the file size. In the future we could change * this to zero the first part of the range then set the file size * which for a non sparse file would zero the newly extended range */ if (keep_size == false) if (i_size_read(inode) < offset + len) return -EOPNOTSUPP; cifs_dbg(FYI, "offset %lld len %lld", offset, len); fsctl_buf.FileOffset = cpu_to_le64(offset); fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, true /* is_fctl */, false /* use_ipc */, (char *)&fsctl_buf, sizeof(struct file_zero_data_information), NULL, NULL); free_xid(xid); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French21297.25%250.00%
David Howells31.38%125.00%
Aurelien Aptel31.38%125.00%
Total218100.00%4100.00%


static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon, loff_t offset, loff_t len) { struct inode *inode; struct cifsInodeInfo *cifsi; struct cifsFileInfo *cfile = file->private_data; struct file_zero_data_information fsctl_buf; long rc; unsigned int xid; __u8 set_sparse = 1; xid = get_xid(); inode = d_inode(cfile->dentry); cifsi = CIFS_I(inode); /* Need to make file sparse, if not already, before freeing range. */ /* Consider adding equivalent for compressed since it could also work */ if (!smb2_set_sparse(xid, tcon, cfile, inode, set_sparse)) return -EOPNOTSUPP; cifs_dbg(FYI, "offset %lld len %lld", offset, len); fsctl_buf.FileOffset = cpu_to_le64(offset); fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, true /* is_fctl */, false /* use_ipc */, (char *)&fsctl_buf, sizeof(struct file_zero_data_information), NULL, NULL); free_xid(xid); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French17996.76%133.33%
David Howells31.62%133.33%
Aurelien Aptel31.62%133.33%
Total185100.00%3100.00%


static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon, loff_t off, loff_t len, bool keep_size) { struct inode *inode; struct cifsInodeInfo *cifsi; struct cifsFileInfo *cfile = file->private_data; long rc = -EOPNOTSUPP; unsigned int xid; xid = get_xid(); inode = d_inode(cfile->dentry); cifsi = CIFS_I(inode); /* if file not oplocked can't be sure whether asking to extend size */ if (!CIFS_CACHE_READ(cifsi)) if (keep_size == false) return -EOPNOTSUPP; /* * Files are non-sparse by default so falloc may be a no-op * Must check if file sparse. If not sparse, and not extending * then no need to do anything since file already allocated */ if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) == 0) { if (keep_size == true) return 0; /* check if extending file */ else if (i_size_read(inode) >= off + len) /* not extending file and already not sparse */ return 0; /* BB: in future add else clause to extend file */ else return -EOPNOTSUPP; } if ((keep_size == true) || (i_size_read(inode) >= off + len)) { /* * Check if falloc starts within first few pages of file * and ends within a few pages of the end of file to * ensure that most of file is being forced to be * fallocated now. If so then setting whole file sparse * ie potentially making a few extra pages at the beginning * or end of the file non-sparse via set_sparse is harmless. */ if ((off > 8192) || (off + len + 8192 < i_size_read(inode))) return -EOPNOTSUPP; rc = smb2_set_sparse(xid, tcon, cfile, inode, false); } /* BB: else ... in future add code to extend file and set sparse */ free_xid(xid); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French20998.58%150.00%
David Howells31.42%150.00%
Total212100.00%2100.00%


static long smb3_fallocate(struct file *file, struct cifs_tcon *tcon, int mode, loff_t off, loff_t len) { /* KEEP_SIZE already checked for by do_fallocate */ if (mode & FALLOC_FL_PUNCH_HOLE) return smb3_punch_hole(file, tcon, off, len); else if (mode & FALLOC_FL_ZERO_RANGE) { if (mode & FALLOC_FL_KEEP_SIZE) return smb3_zero_range(file, tcon, off, len, true); return smb3_zero_range(file, tcon, off, len, false); } else if (mode == FALLOC_FL_KEEP_SIZE) return smb3_simple_falloc(file, tcon, off, len, true); else if (mode == 0) return smb3_simple_falloc(file, tcon, off, len, false); return -EOPNOTSUPP; }

Contributors

PersonTokensPropCommitsCommitProp
Steve French133100.00%3100.00%
Total133100.00%3100.00%


static void smb2_downgrade_oplock(struct TCP_Server_Info *server, struct cifsInodeInfo *cinode, bool set_level2) { if (set_level2) server->ops->set_oplock_level(cinode, SMB2_OPLOCK_LEVEL_II, 0, NULL); else server->ops->set_oplock_level(cinode, 0, 0, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
Sachin S. Prabhu5296.30%150.00%
Pavel Shilovsky23.70%150.00%
Total54100.00%2100.00%


static void smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock, unsigned int epoch, bool *purge_cache) { oplock &= 0xFF; if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE) return; if (oplock == SMB2_OPLOCK_LEVEL_BATCH) { cinode->oplock = CIFS_CACHE_RHW_FLG; cifs_dbg(FYI, "Batch Oplock granted on inode %p\n", &cinode->vfs_inode); } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) { cinode->oplock = CIFS_CACHE_RW_FLG; cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n", &cinode->vfs_inode); } else if (oplock == SMB2_OPLOCK_LEVEL_II) { cinode->oplock = CIFS_CACHE_READ_FLG; cifs_dbg(FYI, "Level II Oplock granted on inode %p\n", &cinode->vfs_inode); } else cinode->oplock = 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky11797.50%675.00%
Sachin S. Prabhu21.67%112.50%
Steve French10.83%112.50%
Total120100.00%8100.00%


static void smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock, unsigned int epoch, bool *purge_cache) { char message[5] = {0}; oplock &= 0xFF; if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE) return; cinode->oplock = 0; if (oplock & SMB2_LEASE_READ_CACHING_HE) { cinode->oplock |= CIFS_CACHE_READ_FLG; strcat(message, "R"); } if (oplock & SMB2_LEASE_HANDLE_CACHING_HE) { cinode->oplock |= CIFS_CACHE_HANDLE_FLG; strcat(message, "H"); } if (oplock & SMB2_LEASE_WRITE_CACHING_HE) { cinode->oplock |= CIFS_CACHE_WRITE_FLG; strcat(message, "W"); } if (!cinode->oplock) strcat(message, "None"); cifs_dbg(FYI, "%s Lease granted on inode %p\n", message, &cinode->vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky140100.00%3100.00%
Total140100.00%3100.00%


static void smb3_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock, unsigned int epoch, bool *purge_cache) { unsigned int old_oplock = cinode->oplock; smb21_set_oplock_level(cinode, oplock, epoch, purge_cache); if (purge_cache) { *purge_cache = false; if (old_oplock == CIFS_CACHE_READ_FLG) { if (cinode->oplock == CIFS_CACHE_READ_FLG && (epoch - cinode->epoch > 0)) *purge_cache = true; else if (cinode->oplock == CIFS_CACHE_RH_FLG && (epoch - cinode->epoch > 1)) *purge_cache = true; else if (cinode->oplock == CIFS_CACHE_RHW_FLG && (epoch - cinode->epoch > 1)) *purge_cache = true; else if (cinode->oplock == 0 && (epoch - cinode->epoch > 0)) *purge_cache = true; } else if (old_oplock == CIFS_CACHE_RH_FLG) { if (cinode->oplock == CIFS_CACHE_RH_FLG && (epoch - cinode->epoch > 0)) *purge_cache = true; else if (cinode->oplock == CIFS_CACHE_RHW_FLG && (epoch - cinode->epoch > 1)) *purge_cache = true; } cinode->epoch = epoch; } }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky217100.00%2100.00%
Total217100.00%2100.00%


static bool smb2_is_read_op(__u32 oplock) { return oplock == SMB2_OPLOCK_LEVEL_II; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky14100.00%2100.00%
Total14100.00%2100.00%


static bool smb21_is_read_op(__u32 oplock) { return (oplock & SMB2_LEASE_READ_CACHING_HE) && !(oplock & SMB2_LEASE_WRITE_CACHING_HE); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky23100.00%1100.00%
Total23100.00%1100.00%


static __le32 map_oplock_to_lease(u8 oplock) { if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING; else if (oplock == SMB2_OPLOCK_LEVEL_II) return SMB2_LEASE_READ_CACHING; else if (oplock == SMB2_OPLOCK_LEVEL_BATCH) return SMB2_LEASE_HANDLE_CACHING | SMB2_LEASE_READ_CACHING | SMB2_LEASE_WRITE_CACHING; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky47100.00%2100.00%
Total47100.00%2100.00%


static char * smb2_create_lease_buf(u8 *lease_key, u8 oplock) { struct create_lease *buf; buf = kzalloc(sizeof(struct create_lease), GFP_KERNEL); if (!buf) return NULL; buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key)); buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8))); buf->lcontext.LeaseState = map_oplock_to_lease(oplock); buf->ccontext.DataOffset = cpu_to_le16(offsetof (struct create_lease, lcontext)); buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context)); buf->ccontext.NameOffset = cpu_to_le16(offsetof (struct create_lease, Name)); buf->ccontext.NameLength = cpu_to_le16(4); /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */ buf->Name[0] = 'R'; buf->Name[1] = 'q'; buf->Name[2] = 'L'; buf->Name[3] = 's'; return (char *)buf; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky19499.49%266.67%
Steve French10.51%133.33%
Total195100.00%3100.00%


static char * smb3_create_lease_buf(u8 *lease_key, u8 oplock) { struct create_lease_v2 *buf; buf = kzalloc(sizeof(struct create_lease_v2), GFP_KERNEL); if (!buf) return NULL; buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key)); buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8))); buf->lcontext.LeaseState = map_oplock_to_lease(oplock); buf->ccontext.DataOffset = cpu_to_le16(offsetof (struct create_lease_v2, lcontext)); buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context_v2)); buf->ccontext.NameOffset = cpu_to_le16(offsetof (struct create_lease_v2, Name)); buf->ccontext.NameLength = cpu_to_le16(4); /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */ buf->Name[0] = 'R'; buf->Name[1] = 'q'; buf->Name[2] = 'L'; buf->Name[3] = 's'; return (char *)buf; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky19499.49%266.67%
Steve French10.51%133.33%
Total195100.00%3100.00%


static __u8 smb2_parse_lease_buf(void *buf, unsigned int *epoch) { struct create_lease *lc = (struct create_lease *)buf; *epoch = 0; /* not used */ if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS) return SMB2_OPLOCK_LEVEL_NOCHANGE; return le32_to_cpu(lc->lcontext.LeaseState); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky56100.00%2100.00%
Total56100.00%2100.00%


static __u8 smb3_parse_lease_buf(void *buf, unsigned int *epoch) { struct create_lease_v2 *lc = (struct create_lease_v2 *)buf; *epoch = le16_to_cpu(lc->lcontext.Epoch); if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS) return SMB2_OPLOCK_LEVEL_NOCHANGE; return le32_to_cpu(lc->lcontext.LeaseState); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky62100.00%2100.00%
Total62100.00%2100.00%


static unsigned int smb2_wp_retry_size(struct inode *inode) { return min_t(unsigned int, CIFS_SB(inode->i_sb)->wsize, SMB2_MAX_BUFFER_SIZE); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky22100.00%1100.00%
Total22100.00%1100.00%


static bool smb2_dir_needs_close(struct cifsFileInfo *cfile) { return !cfile->invalidHandle; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky17100.00%1100.00%
Total17100.00%1100.00%


static void fill_transform_hdr(struct smb2_transform_hdr *tr_hdr, struct smb_rqst *old_rq) { struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)old_rq->rq_iov[1].iov_base; unsigned int orig_len = get_rfc1002_length(old_rq->rq_iov[0].iov_base); memset(tr_hdr, 0, sizeof(struct smb2_transform_hdr)); tr_hdr->ProtocolId = SMB2_TRANSFORM_PROTO_NUM; tr_hdr->OriginalMessageSize = cpu_to_le32(orig_len); tr_hdr->Flags = cpu_to_le16(0x01); get_random_bytes(&tr_hdr->Nonce, SMB3_AES128CMM_NONCE); memcpy(&tr_hdr->SessionId, &shdr->SessionId, 8); inc_rfc1001_len(tr_hdr, sizeof(struct smb2_transform_hdr) - 4); inc_rfc1001_len(tr_hdr, orig_len); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky133100.00%2100.00%
Total133100.00%2100.00%


static struct scatterlist * init_sg(struct smb_rqst *rqst, u8 *sign) { unsigned int sg_len = rqst->rq_nvec + rqst->rq_npages + 1; unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; struct scatterlist *sg; unsigned int i; unsigned int j; sg = kmalloc_array(sg_len, sizeof(struct scatterlist), GFP_KERNEL); if (!sg) return NULL; sg_init_table(sg, sg_len); sg_set_buf(&sg[0], rqst->rq_iov[0].iov_base + 24, assoc_data_len); for (i = 1; i < rqst->rq_nvec; i++) sg_set_buf(&sg[i], rqst->rq_iov[i].iov_base, rqst->rq_iov[i].iov_len); for (j = 0; i < sg_len - 1; i++, j++) { unsigned int len = (j < rqst->rq_npages - 1) ? rqst->rq_pagesz : rqst->rq_tailsz; sg_set_page(&sg[i], rqst->rq_pages[j], len, 0); } sg_set_buf(&sg[sg_len - 1], sign, SMB2_SIGNATURE_SIZE); return sg; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky230100.00%3100.00%
Total230100.00%3100.00%

struct cifs_crypt_result { int err; struct completion completion; };
static void cifs_crypt_complete(struct crypto_async_request *req, int err) { struct cifs_crypt_result *res = req->data; if (err == -EINPROGRESS) return; res->err = err; complete(&res->completion); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky45100.00%1100.00%
Total45100.00%1100.00%


static int smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key) { struct cifs_ses *ses; u8 *ses_enc_key; spin_lock(&cifs_tcp_ses_lock); list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) { if (ses->Suid != ses_id) continue; ses_enc_key = enc ? ses->smb3encryptionkey : ses->smb3decryptionkey; memcpy(key, ses_enc_key, SMB3_SIGN_KEY_SIZE); spin_unlock(&cifs_tcp_ses_lock); return 0; } spin_unlock(&cifs_tcp_ses_lock); return 1; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky94100.00%1100.00%
Total94100.00%1100.00%

/* * Encrypt or decrypt @rqst message. @rqst has the following format: * iov[0] - transform header (associate data), * iov[1-N] and pages - data to encrypt. * On success return encrypted data in iov[1-N] and pages, leave iov[0] * untouched. */
static int crypt_message(struct TCP_Server_Info *server, struct smb_rqst *rqst, int enc) { struct smb2_transform_hdr *tr_hdr = (struct smb2_transform_hdr *)rqst->rq_iov[0].iov_base; unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24; int rc = 0; struct scatterlist *sg; u8 sign[SMB2_SIGNATURE_SIZE] = {}; u8 key[SMB3_SIGN_KEY_SIZE]; struct aead_request *req; char *iv; unsigned int iv_len; struct cifs_crypt_result result = {0, }; struct crypto_aead *tfm; unsigned int crypt_len = le32_to_cpu(tr_hdr->OriginalMessageSize); init_completion(&result.completion); rc = smb2_get_enc_key(server, tr_hdr->SessionId, enc, key); if (rc) { cifs_dbg(VFS, "%s: Could not get %scryption key\n", __func__, enc ? "en" : "de"); return 0; } rc = smb3_crypto_aead_allocate(server); if (rc) { cifs_dbg(VFS, "%s: crypto alloc failed\n", __func__); return rc; } tfm = enc ? server->secmech.ccmaesencrypt : server->secmech.ccmaesdecrypt; rc = crypto_aead_setkey(tfm, key, SMB3_SIGN_KEY_SIZE); if (rc) { cifs_dbg(VFS, "%s: Failed to set aead key %d\n", __func__, rc); return rc; } rc = crypto_aead_setauthsize(tfm, SMB2_SIGNATURE_SIZE); if (rc) { cifs_dbg(VFS, "%s: Failed to set authsize %d\n", __func__, rc); return rc; } req = aead_request_alloc(tfm, GFP_KERNEL); if (!req) { cifs_dbg(VFS, "%s: Failed to alloc aead request", __func__); return -ENOMEM; } if (!enc) { memcpy(sign, &tr_hdr->Signature, SMB2_SIGNATURE_SIZE); crypt_len += SMB2_SIGNATURE_SIZE; } sg = init_sg(rqst, sign); if (!sg) { cifs_dbg(VFS, "%s: Failed to init sg %d", __func__, rc); goto free_req; } iv_len = crypto_aead_ivsize(tfm); iv = kzalloc(iv_len, GFP_KERNEL); if (!iv) { cifs_dbg(VFS, "%s: Failed to alloc IV", __func__); goto free_sg; } iv[0] = 3; memcpy(iv + 1, (char *)tr_hdr->Nonce, SMB3_AES128CMM_NONCE); aead_request_set_crypt(req, sg, sg, crypt_len, iv); aead_request_set_ad(req, assoc_data_len); aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, cifs_crypt_complete, &result); rc = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req); if (rc == -EINPROGRESS || rc == -EBUSY) { wait_for_completion(&result.completion); rc = result.err; } if (!rc && enc) memcpy(&tr_hdr->Signature, sign, SMB2_SIGNATURE_SIZE); kfree(iv); free_sg: kfree(sg); free_req: kfree(req); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky515100.00%2100.00%
Total515100.00%2100.00%


static int smb3_init_transform_rq(struct TCP_Server_Info *server, struct smb_rqst *new_rq, struct smb_rqst *old_rq) { struct kvec *iov; struct page **pages; struct smb2_transform_hdr *tr_hdr; unsigned int npages = old_rq->rq_npages; int i; int rc = -ENOMEM; pages = kmalloc_array(npages, sizeof(struct page *), GFP_KERNEL); if (!pages) return rc; new_rq->rq_pages = pages; new_rq->rq_npages = old_rq->rq_npages; new_rq->rq_pagesz = old_rq->rq_pagesz; new_rq->rq_tailsz = old_rq->rq_tailsz; for (i = 0; i < npages; i++) { pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM); if (!pages[i]) goto err_free_pages; } iov = kmalloc_array(old_rq->rq_nvec, sizeof(struct kvec), GFP_KERNEL); if (!iov) goto err_free_pages; /* copy all iovs from the old except the 1st one (rfc1002 length) */ memcpy(&iov[1], &old_rq->rq_iov[1], sizeof(struct kvec) * (old_rq->rq_nvec - 1)); new_rq->rq_iov = iov; new_rq->rq_nvec = old_rq->rq_nvec; tr_hdr = kmalloc(sizeof(struct smb2_transform_hdr), GFP_KERNEL); if (!tr_hdr) goto err_free_iov; /* fill the 1st iov with a transform header */ fill_transform_hdr(tr_hdr, old_rq); new_rq->rq_iov[0].iov_base = tr_hdr; new_rq->rq_iov[0].iov_len = sizeof(struct smb2_transform_hdr); /* copy pages form the old */ for (i = 0; i < npages; i++) { char *dst = kmap(new_rq->rq_pages[i]); char *src = kmap(old_rq->rq_pages[i]); unsigned int len = (i < npages - 1) ? new_rq->rq_pagesz : new_rq->rq_tailsz; memcpy(dst, src, len); kunmap(new_rq->rq_pages[i]); kunmap(old_rq->rq_pages[i]); } rc = crypt_message(server, new_rq, 1); cifs_dbg(FYI, "encrypt message returned %d", rc); if (rc) goto err_free_tr_hdr; return rc; err_free_tr_hdr: kfree(tr_hdr); err_free_iov: kfree(iov); err_free_pages: for (i = i - 1; i >= 0; i--) put_page(pages[i]); kfree(pages); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky442100.00%1100.00%
Total442100.00%1100.00%


static void smb3_free_transform_rq(struct smb_rqst *rqst) { int i = rqst->rq_npages - 1; for (; i >= 0; i--) put_page(rqst->rq_pages[i]); kfree(rqst->rq_pages); /* free transform header */ kfree(rqst->rq_iov[0].iov_base); kfree(rqst->rq_iov); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky67100.00%1100.00%
Total67100.00%1100.00%


static int smb3_is_transform_hdr(void *buf) { struct smb2_transform_hdr *trhdr = buf; return trhdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky24100.00%1100.00%
Total24100.00%1100.00%


static int decrypt_raw_data(struct TCP_Server_Info *server, char *buf, unsigned int buf_data_size, struct page **pages, unsigned int npages, unsigned int page_data_size) { struct kvec iov[2]; struct smb_rqst rqst = {NULL}; struct smb2_hdr *hdr; int rc; iov[0].iov_base = buf; iov[0].iov_len = sizeof(struct smb2_transform_hdr); iov[1].iov_base = buf + sizeof(struct smb2_transform_hdr); iov[1].iov_len = buf_data_size; rqst.rq_iov = iov; rqst.rq_nvec = 2; rqst.rq_pages = pages; rqst.rq_npages = npages; rqst.rq_pagesz = PAGE_SIZE; rqst.rq_tailsz = (page_data_size % PAGE_SIZE) ? : PAGE_SIZE; rc = crypt_message(server, &rqst, 0); cifs_dbg(FYI, "decrypt message returned %d\n", rc); if (rc) return rc; memmove(buf + 4, iov[1].iov_base, buf_data_size); hdr = (struct smb2_hdr *)buf; hdr->smb2_buf_length = cpu_to_be32(buf_data_size + page_data_size); server->total_read = buf_data_size + page_data_size + 4; return rc; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky222100.00%1100.00%
Total222100.00%1100.00%


static int read_data_into_pages(struct TCP_Server_Info *server, struct page **pages, unsigned int npages, unsigned int len) { int i; int length; for (i = 0; i < npages; i++) { struct page *page = pages[i]; size_t n; n = len; if (len >= PAGE_SIZE) { /* enough data to fill the page */ n = PAGE_SIZE; len -= n; } else { zero_user(page, len, PAGE_SIZE - len); len = 0; } length = cifs_read_page_from_socket(server, page, n); if (length < 0) return length; server->total_read += length; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky127100.00%2100.00%
Total127100.00%2100.00%


static int init_read_bvec(struct page **pages, unsigned int npages, unsigned int data_size, unsigned int cur_off, struct bio_vec **page_vec) { struct bio_vec *bvec; int i; bvec = kcalloc(npages, sizeof(struct bio_vec), GFP_KERNEL); if (!bvec) return -ENOMEM; for (i = 0; i < npages; i++) { bvec[i].bv_page = pages[i]; bvec[i].bv_offset = (i == 0) ? cur_off : 0; bvec[i].bv_len = min_t(unsigned int, PAGE_SIZE, data_size); data_size -= bvec[i].bv_len; } if (data_size != 0) { cifs_dbg(VFS, "%s: something went wrong\n", __func__); kfree(bvec); return -EIO; } *page_vec = bvec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky165100.00%2100.00%
Total165100.00%2100.00%


static int handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid, char *buf, unsigned int buf_len, struct page **pages, unsigned int npages, unsigned int page_data_size) { unsigned int data_offset; unsigned int data_len; unsigned int cur_off; unsigned int cur_page_idx; unsigned int pad_len; struct cifs_readdata *rdata = mid->callback_data; struct smb2_sync_hdr *shdr = get_sync_hdr(buf); struct bio_vec *bvec = NULL; struct iov_iter iter; struct kvec iov; int length; if (shdr->Command != SMB2_READ) { cifs_dbg(VFS, "only big read responses are supported\n"); return -ENOTSUPP; } if (server->ops->is_status_pending && server->ops->is_status_pending(buf, server, 0)) return -1; rdata->result = server->ops->map_error(buf, false); if (rdata->result != 0) { cifs_dbg(FYI, "%s: server returned error %d\n", __func__, rdata->result); dequeue_mid(mid, rdata->result); return 0; } data_offset = server->ops->read_data_offset(buf) + 4; data_len = server->ops->read_data_length(buf); if (data_offset < server->vals->read_rsp_size) { /* * win2k8 sometimes sends an offset of 0 when the read * is beyond the EOF. Treat it as if the data starts just after * the header. */ cifs_dbg(FYI, "%s: data offset (%u) inside read response header\n", __func__, data_offset); data_offset = server->vals->read_rsp_size; } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) { /* data_offset is beyond the end of smallbuf */ cifs_dbg(FYI, "%s: data offset (%u) beyond end of smallbuf\n", __func__, data_offset); rdata->result = -EIO; dequeue_mid(mid, rdata->result); return 0; } pad_len = data_offset - server->vals->read_rsp_size; if (buf_len <= data_offset) { /* read response payload is in pages */ cur_page_idx = pad_len / PAGE_SIZE; cur_off = pad_len % PAGE_SIZE; if (cur_page_idx != 0) { /* data offset is beyond the 1st page of response */ cifs_dbg(FYI, "%s: data offset (%u) beyond 1st page of response\n", __func__, data_offset); rdata->result = -EIO; dequeue_mid(mid, rdata->result); return 0; } if (data_len > page_data_size - pad_len) { /* data_len is corrupt -- discard frame */ rdata->result = -EIO; dequeue_mid(mid, rdata->result); return 0; } rdata->result = init_read_bvec(pages, npages, page_data_size, cur_off, &bvec); if (rdata->result != 0) { dequeue_mid(mid, rdata->result); return 0; } iov_iter_bvec(&iter, WRITE | ITER_BVEC, bvec, npages, data_len); } else if (buf_len >= data_offset + data_len) { /* read response payload is in buf */ WARN_ONCE(npages > 0, "read data can be either in buf or in pages"); iov.iov_base = buf + data_offset; iov.iov_len = data_len; iov_iter_kvec(&iter, WRITE | ITER_KVEC, &iov, 1, data_len); } else { /* read response payload cannot be in both buf and pages */ WARN_ONCE(1, "buf can not contain only a part of read data"); rdata->result = -EIO; dequeue_mid(mid, rdata->result); return 0; } /* set up first iov for signature check */ rdata->iov[0].iov_base = buf; rdata->iov[0].iov_len = 4; rdata->iov[1].iov_base = buf + 4; rdata->iov[1].iov_len = server->vals->read_rsp_size - 4; cifs_dbg(FYI, "0: iov_base=%p iov_len=%zu\n", rdata->iov[0].iov_base, server->vals->read_rsp_size); length = rdata->copy_into_pages(server, rdata, &iter); kfree(bvec); if (length < 0) return length; dequeue_mid(mid, false); return length; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky638100.00%1100.00%
Total638100.00%1100.00%


static int receive_encrypted_read(struct TCP_Server_Info *server, struct mid_q_entry **mid) { char *buf = server->smallbuf; struct smb2_transform_hdr *tr_hdr = (struct smb2_transform_hdr *)buf; unsigned int npages; struct page **pages; unsigned int len; unsigned int buflen = get_rfc1002_length(buf) + 4; int rc; int i = 0; len = min_t(unsigned int, buflen, server->vals->read_rsp_size - 4 + sizeof(struct smb2_transform_hdr)) - HEADER_SIZE(server) + 1; rc = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, len); if (rc < 0) return rc; server->total_read += rc; len = le32_to_cpu(tr_hdr->OriginalMessageSize) + 4 - server->vals->read_rsp_size; npages = DIV_ROUND_UP(len, PAGE_SIZE); pages = kmalloc_array(npages, sizeof(struct page *), GFP_KERNEL); if (!pages) { rc = -ENOMEM; goto discard_data; } for (; i < npages; i++) { pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM); if (!pages[i]) { rc = -ENOMEM; goto discard_data; } } /* read read data into pages */ rc = read_data_into_pages(server, pages, npages, len); if (rc) goto free_pages; rc = cifs_discard_remaining_data(server); if (rc) goto free_pages; rc = decrypt_raw_data(server, buf, server->vals->read_rsp_size - 4, pages, npages, len); if (rc) goto free_pages; *mid = smb2_find_mid(server, buf); if (*mid == NULL) cifs_dbg(FYI, "mid not found\n"); else { cifs_dbg(FYI, "mid found\n"); (*mid)->decrypted = true; rc = handle_read_data(server, *mid, buf, server->vals->read_rsp_size, pages, npages, len); } free_pages: for (i = i - 1; i >= 0; i--) put_page(pages[i]); kfree(pages); return rc; discard_data: cifs_discard_remaining_data(server); goto free_pages; }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky397100.00%2100.00%
Total397100.00%2100.00%


static int receive_encrypted_standard(struct TCP_Server_Info *server, struct mid_q_entry **mid) { int length; char *buf = server->smallbuf; unsigned int pdu_length = get_rfc1002_length(buf); unsigned int buf_size; struct mid_q_entry *mid_entry; /* switch to large buffer if too big for a small one */ if (pdu_length + 4 > MAX_CIFS_SMALL_BUFFER_SIZE) { server->large_buf = true; memcpy(server->bigbuf, buf, server->total_read); buf = server->bigbuf; } /* now read the rest */ length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, pdu_length - HEADER_SIZE(server) + 1 + 4); if (length < 0) return length; server->total_read += length; buf_size = pdu_length + 4 - sizeof(struct smb2_transform_hdr); length = decrypt_raw_data(server, buf, buf_size, NULL, 0, 0); if (length) return length; mid_entry = smb2_find_mid(server, buf); if (mid_entry == NULL) cifs_dbg(FYI, "mid not found\n"); else { cifs_dbg(FYI, "mid found\n"); mid_entry->decrypted = true; } *mid = mid_entry; if (mid_entry && mid_entry->handle) return mid_entry->handle(server, mid_entry); return cifs_handle_standard(server, mid_entry); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky230100.00%1100.00%
Total230100.00%1100.00%


static int smb3_receive_transform(struct TCP_Server_Info *server, struct mid_q_entry **mid) { char *buf = server->smallbuf; unsigned int pdu_length = get_rfc1002_length(buf); struct smb2_transform_hdr *tr_hdr = (struct smb2_transform_hdr *)buf; unsigned int orig_len = le32_to_cpu(tr_hdr->OriginalMessageSize); if (pdu_length + 4 < sizeof(struct smb2_transform_hdr) + sizeof(struct smb2_sync_hdr)) { cifs_dbg(VFS, "Transform message is too small (%u)\n", pdu_length); cifs_reconnect(server); wake_up(&server->response_q); return -ECONNABORTED; } if (pdu_length + 4 < orig_len + sizeof(struct smb2_transform_hdr)) { cifs_dbg(VFS, "Transform message is broken\n"); cifs_reconnect(server); wake_up(&server->response_q); return -ECONNABORTED; } if (pdu_length + 4 > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) return receive_encrypted_read(server, mid); return receive_encrypted_standard(server, mid); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky172100.00%2100.00%
Total172100.00%2100.00%


int smb3_handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid) { char *buf = server->large_buf ? server->bigbuf : server->smallbuf; return handle_read_data(server, mid, buf, get_rfc1002_length(buf) + 4, NULL, 0, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky54100.00%1100.00%
Total54100.00%1100.00%

struct smb_version_operations smb20_operations = { .compare_fids = smb2_compare_fids, .setup_request = smb2_setup_request, .setup_async_request = smb2_setup_async_request, .check_receive = smb2_check_receive, .add_credits = smb2_add_credits, .set_credits = smb2_set_credits, .get_credits_field = smb2_get_credits_field, .get_credits = smb2_get_credits, .wait_mtu_credits = cifs_wait_mtu_credits, .get_next_mid = smb2_get_next_mid, .read_data_offset = smb2_read_data_offset, .read_data_length = smb2_read_data_length, .map_error = map_smb2_to_linux_error, .find_mid = smb2_find_mid, .check_message = smb2_check_message, .dump_detail = smb2_dump_detail, .clear_stats = smb2_clear_stats, .print_stats = smb2_print_stats, .is_oplock_break = smb2_is_valid_oplock_break, .handle_cancelled_mid = smb2_handle_cancelled_mid, .downgrade_oplock = smb2_downgrade_oplock, .need_neg = smb2_need_neg, .negotiate = smb2_negotiate, .negotiate_wsize = smb2_negotiate_wsize, .negotiate_rsize = smb2_negotiate_rsize, .sess_setup = SMB2_sess_setup, .logoff = SMB2_logoff, .tree_connect = SMB2_tcon, .tree_disconnect = SMB2_tdis, .qfs_tcon = smb2_qfs_tcon, .is_path_accessible = smb2_is_path_accessible, .can_echo = smb2_can_echo, .echo = SMB2_echo, .query_path_info = smb2_query_path_info, .get_srv_inum = smb2_get_srv_inum, .query_file_info = smb2_query_file_info, .set_path_size = smb2_set_path_size, .set_file_size = smb2_set_file_size, .set_file_info = smb2_set_file_info, .set_compression = smb2_set_compression, .mkdir = smb2_mkdir, .mkdir_setinfo = smb2_mkdir_setinfo, .rmdir = smb2_rmdir, .unlink = smb2_unlink, .rename = smb2_rename_path, .create_hardlink = smb2_create_hardlink, .query_symlink = smb2_query_symlink, .query_mf_symlink = smb3_query_mf_symlink, .create_mf_symlink = smb3_create_mf_symlink, .open = smb2_open_file, .set_fid = smb2_set_fid, .close = smb2_close_file, .flush = smb2_flush_file, .async_readv = smb2_async_readv, .async_writev = smb2_async_writev, .sync_read = smb2_sync_read, .sync_write = smb2_sync_write, .query_dir_first = smb2_query_dir_first, .query_dir_next = smb2_query_dir_next, .close_dir = smb2_close_dir, .calc_smb_size = smb2_calc_size, .is_status_pending = smb2_is_status_pending, .oplock_response = smb2_oplock_response, .queryfs = smb2_queryfs, .mand_lock = smb2_mand_lock, .mand_unlock_range = smb2_unlock_range, .push_mand_locks = smb2_push_mandatory_locks, .get_lease_key = smb2_get_lease_key, .set_lease_key = smb2_set_lease_key, .new_lease_key = smb2_new_lease_key, .calc_signature = smb2_calc_signature, .is_read_op = smb2_is_read_op, .set_oplock_level = smb2_set_oplock_level, .create_lease_buf = smb2_create_lease_buf, .parse_lease_buf = smb2_parse_lease_buf, .copychunk_range = smb2_copychunk_range, .wp_retry_size = smb2_wp_retry_size, .dir_needs_close = smb2_dir_needs_close, .get_dfs_refer = smb2_get_dfs_refer, .select_sectype = smb2_select_sectype, }; struct smb_version_operations smb21_operations = { .compare_fids = smb2_compare_fids, .setup_request = smb2_setup_request, .setup_async_request = smb2_setup_async_request, .check_receive = smb2_check_receive, .add_credits = smb2_add_credits, .set_credits = smb2_set_credits, .get_credits_field = smb2_get_credits_field, .get_credits = smb2_get_credits, .wait_mtu_credits = smb2_wait_mtu_credits, .get_next_mid = smb2_get_next_mid, .read_data_offset = smb2_read_data_offset, .read_data_length = smb2_read_data_length, .map_error = map_smb2_to_linux_error, .find_mid = smb2_find_mid, .check_message = smb2_check_message, .dump_detail = smb2_dump_detail, .clear_stats = smb2_clear_stats, .print_stats = smb2_print_stats, .is_oplock_break = smb2_is_valid_oplock_break, .handle_cancelled_mid = smb2_handle_cancelled_mid, .downgrade_oplock = smb2_downgrade_oplock, .need_neg = smb2_need_neg, .negotiate = smb2_negotiate, .negotiate_wsize = smb2_negotiate_wsize, .negotiate_rsize = smb2_negotiate_rsize, .sess_setup = SMB2_sess_setup, .logoff = SMB2_logoff, .tree_connect = SMB2_tcon, .tree_disconnect = SMB2_tdis, .qfs_tcon = smb2_qfs_tcon, .is_path_accessible = smb2_is_path_accessible, .can_echo = smb2_can_echo, .echo = SMB2_echo, .query_path_info = smb2_query_path_info, .get_srv_inum = smb2_get_srv_inum, .query_file_info = smb2_query_file_info, .set_path_size = smb2_set_path_size, .set_file_size = smb2_set_file_size, .set_file_info = smb2_set_file_info, .set_compression = smb2_set_compression, .mkdir = smb2_mkdir, .mkdir_setinfo = smb2_mkdir_setinfo, .rmdir = smb2_rmdir, .unlink = smb2_unlink, .rename = smb2_rename_path, .create_hardlink = smb2_create_hardlink, .query_symlink = smb2_query_symlink, .query_mf_symlink = smb3_query_mf_symlink, .create_mf_symlink = smb3_create_mf_symlink, .open = smb2_open_file, .set_fid = smb2_set_fid, .close = smb2_close_file, .flush = smb2_flush_file, .async_readv = smb2_async_readv, .async_writev = smb2_async_writev, .sync_read = smb2_sync_read, .sync_write = smb2_sync_write, .query_dir_first = smb2_query_dir_first, .query_dir_next = smb2_query_dir_next, .close_dir = smb2_close_dir, .calc_smb_size = smb2_calc_size, .is_status_pending = smb2_is_status_pending, .oplock_response = smb2_oplock_response, .queryfs = smb2_queryfs, .mand_lock = smb2_mand_lock, .mand_unlock_range = smb2_unlock_range, .push_mand_locks = smb2_push_mandatory_locks, .get_lease_key = smb2_get_lease_key, .set_lease_key = smb2_set_lease_key, .new_lease_key = smb2_new_lease_key, .calc_signature = smb2_calc_signature, .is_read_op = smb21_is_read_op, .set_oplock_level = smb21_set_oplock_level, .create_lease_buf = smb2_create_lease_buf, .parse_lease_buf = smb2_parse_lease_buf, .copychunk_range = smb2_copychunk_range, .wp_retry_size = smb2_wp_retry_size, .dir_needs_close = smb2_dir_needs_close, .enum_snapshots = smb3_enum_snapshots, .get_dfs_refer = smb2_get_dfs_refer, .select_sectype = smb2_select_sectype, }; struct smb_version_operations smb30_operations = { .compare_fids = smb2_compare_fids, .setup_request = smb2_setup_request, .setup_async_request = smb2_setup_async_request, .check_receive = smb2_check_receive, .add_credits = smb2_add_credits, .set_credits = smb2_set_credits, .get_credits_field = smb2_get_credits_field, .get_credits = smb2_get_credits, .wait_mtu_credits = smb2_wait_mtu_credits, .get_next_mid = smb2_get_next_mid, .read_data_offset = smb2_read_data_offset, .read_data_length = smb2_read_data_length, .map_error = map_smb2_to_linux_error, .find_mid = smb2_find_mid, .check_message = smb2_check_message, .dump_detail = smb2_dump_detail, .clear_stats = smb2_clear_stats, .print_stats = smb2_print_stats, .dump_share_caps = smb2_dump_share_caps, .is_oplock_break = smb2_is_valid_oplock_break, .handle_cancelled_mid = smb2_handle_cancelled_mid, .downgrade_oplock = smb2_downgrade_oplock, .need_neg = smb2_need_neg, .negotiate = smb2_negotiate, .negotiate_wsize = smb2_negotiate_wsize, .negotiate_rsize = smb2_negotiate_rsize, .sess_setup = SMB2_sess_setup, .logoff = SMB2_logoff, .tree_connect = SMB2_tcon, .tree_disconnect = SMB2_tdis, .qfs_tcon = smb3_qfs_tcon, .is_path_accessible = smb2_is_path_accessible, .can_echo = smb2_can_echo, .echo = SMB2_echo, .query_path_info = smb2_query_path_info, .get_srv_inum = smb2_get_srv_inum, .query_file_info = smb2_query_file_info, .set_path_size = smb2_set_path_size, .set_file_size = smb2_set_file_size, .set_file_info = smb2_set_file_info, .set_compression = smb2_set_compression, .mkdir = smb2_mkdir, .mkdir_setinfo = smb2_mkdir_setinfo, .rmdir = smb2_rmdir, .unlink = smb2_unlink, .rename = smb2_rename_path, .create_hardlink = smb2_create_hardlink, .query_symlink = smb2_query_symlink, .query_mf_symlink = smb3_query_mf_symlink, .create_mf_symlink = smb3_create_mf_symlink, .open = smb2_open_file, .set_fid = smb2_set_fid, .close = smb2_close_file, .flush = smb2_flush_file, .async_readv = smb2_async_readv, .async_writev = smb2_async_writev, .sync_read = smb2_sync_read, .sync_write = smb2_sync_write, .query_dir_first = smb2_query_dir_first, .query_dir_next = smb2_query_dir_next, .close_dir = smb2_close_dir, .calc_smb_size = smb2_calc_size, .is_status_pending = smb2_is_status_pending, .oplock_response = smb2_oplock_response, .queryfs = smb2_queryfs, .mand_lock = smb2_mand_lock, .mand_unlock_range = smb2_unlock_range, .push_mand_locks = smb2_push_mandatory_locks, .get_lease_key = smb2_get_lease_key, .set_lease_key = smb2_set_lease_key, .new_lease_key = smb2_new_lease_key, .generate_signingkey = generate_smb30signingkey, .calc_signature = smb3_calc_signature, .set_integrity = smb3_set_integrity, .is_read_op = smb21_is_read_op, .set_oplock_level = smb3_set_oplock_level, .create_lease_buf = smb3_create_lease_buf, .parse_lease_buf = smb3_parse_lease_buf, .copychunk_range = smb2_copychunk_range, .duplicate_extents = smb2_duplicate_extents, .validate_negotiate = smb3_validate_negotiate, .wp_retry_size = smb2_wp_retry_size, .dir_needs_close = smb2_dir_needs_close, .fallocate = smb3_fallocate, .enum_snapshots = smb3_enum_snapshots, .init_transform_rq = smb3_init_transform_rq, .free_transform_rq = smb3_free_transform_rq, .is_transform_hdr = smb3_is_transform_hdr, .receive_transform = smb3_receive_transform, .get_dfs_refer = smb2_get_dfs_refer, .select_sectype = smb2_select_sectype, }; #ifdef CONFIG_CIFS_SMB311 struct smb_version_operations smb311_operations = { .compare_fids = smb2_compare_fids, .setup_request = smb2_setup_request, .setup_async_request = smb2_setup_async_request, .check_receive = smb2_check_receive, .add_credits = smb2_add_credits, .set_credits = smb2_set_credits, .get_credits_field = smb2_get_credits_field, .get_credits = smb2_get_credits, .wait_mtu_credits = smb2_wait_mtu_credits, .get_next_mid = smb2_get_next_mid, .read_data_offset = smb2_read_data_offset, .read_data_length = smb2_read_data_length, .map_error = map_smb2_to_linux_error, .find_mid = smb2_find_mid, .check_message = smb2_check_message, .dump_detail = smb2_dump_detail, .clear_stats = smb2_clear_stats, .print_stats = smb2_print_stats, .dump_share_caps = smb2_dump_share_caps, .is_oplock_break = smb2_is_valid_oplock_break, .handle_cancelled_mid = smb2_handle_cancelled_mid, .downgrade_oplock = smb2_downgrade_oplock, .need_neg = smb2_need_neg, .negotiate = smb2_negotiate, .negotiate_wsize = smb2_negotiate_wsize, .negotiate_rsize = smb2_negotiate_rsize, .sess_setup = SMB2_sess_setup, .logoff = SMB2_logoff, .tree_connect = SMB2_tcon, .tree_disconnect = SMB2_tdis, .qfs_tcon = smb3_qfs_tcon, .is_path_accessible = smb2_is_path_accessible, .can_echo = smb2_can_echo, .echo = SMB2_echo, .query_path_info = smb2_query_path_info, .get_srv_inum = smb2_get_srv_inum, .query_file_info = smb2_query_file_info, .set_path_size = smb2_set_path_size, .set_file_size = smb2_set_file_size, .set_file_info = smb2_set_file_info, .set_compression = smb2_set_compression, .mkdir = smb2_mkdir, .mkdir_setinfo = smb2_mkdir_setinfo, .rmdir = smb2_rmdir, .unlink = smb2_unlink, .rename = smb2_rename_path, .create_hardlink = smb2_create_hardlink, .query_symlink = smb2_query_symlink, .query_mf_symlink = smb3_query_mf_symlink, .create_mf_symlink = smb3_create_mf_symlink, .open = smb2_open_file, .set_fid = smb2_set_fid, .close = smb2_close_file, .flush = smb2_flush_file, .async_readv = smb2_async_readv, .async_writev = smb2_async_writev, .sync_read = smb2_sync_read, .sync_write = smb2_sync_write, .query_dir_first = smb2_query_dir_first, .query_dir_next = smb2_query_dir_next, .close_dir = smb2_close_dir, .calc_smb_size = smb2_calc_size, .is_status_pending = smb2_is_status_pending, .oplock_response = smb2_oplock_response, .queryfs = smb2_queryfs, .mand_lock = smb2_mand_lock, .mand_unlock_range = smb2_unlock_range, .push_mand_locks = smb2_push_mandatory_locks, .get_lease_key = smb2_get_lease_key, .set_lease_key = smb2_set_lease_key, .new_lease_key = smb2_new_lease_key, .generate_signingkey = generate_smb311signingkey, .calc_signature = smb3_calc_signature, .set_integrity = smb3_set_integrity, .is_read_op = smb21_is_read_op, .set_oplock_level = smb3_set_oplock_level, .create_lease_buf = smb3_create_lease_buf, .parse_lease_buf = smb3_parse_lease_buf, .copychunk_range = smb2_copychunk_range, .duplicate_extents = smb2_duplicate_extents, /* .validate_negotiate = smb3_validate_negotiate, */ /* not used in 3.11 */ .wp_retry_size = smb2_wp_retry_size, .dir_needs_close = smb2_dir_needs_close, .fallocate = smb3_fallocate, .enum_snapshots = smb3_enum_snapshots, .init_transform_rq = smb3_init_transform_rq, .free_transform_rq = smb3_free_transform_rq, .is_transform_hdr = smb3_is_transform_hdr, .receive_transform = smb3_receive_transform, .get_dfs_refer = smb2_get_dfs_refer, .select_sectype = smb2_select_sectype, }; #endif /* CIFS_SMB311 */ struct smb_version_values smb20_values = { .version_string = SMB20_VERSION_STRING, .protocol_id = SMB20_PROT_ID, .req_capabilities = 0, /* MBZ */ .large_lock_type = 0, .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, .header_size = sizeof(struct smb2_hdr), .max_header_size = MAX_SMB2_HDR_SIZE, .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, .lock_cmd = SMB2_LOCK, .cap_unix = 0, .cap_nt_find = SMB2_NT_FIND, .cap_large_files = SMB2_LARGE_FILES, .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, .create_lease_size = sizeof(struct create_lease), }; struct smb_version_values smb21_values = { .version_string = SMB21_VERSION_STRING, .protocol_id = SMB21_PROT_ID, .req_capabilities = 0, /* MBZ on negotiate req until SMB3 dialect */ .large_lock_type = 0, .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, .header_size = sizeof(struct smb2_hdr), .max_header_size = MAX_SMB2_HDR_SIZE, .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, .lock_cmd = SMB2_LOCK, .cap_unix = 0, .cap_nt_find = SMB2_NT_FIND, .cap_large_files = SMB2_LARGE_FILES, .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, .create_lease_size = sizeof(struct create_lease), }; struct smb_version_values smb30_values = { .version_string = SMB30_VERSION_STRING, .protocol_id = SMB30_PROT_ID, .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION, .large_lock_type = 0, .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, .header_size = sizeof(struct smb2_hdr), .max_header_size = MAX_SMB2_HDR_SIZE, .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, .lock_cmd = SMB2_LOCK, .cap_unix = 0, .cap_nt_find = SMB2_NT_FIND, .cap_large_files = SMB2_LARGE_FILES, .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, .create_lease_size = sizeof(struct create_lease_v2), }; struct smb_version_values smb302_values = { .version_string = SMB302_VERSION_STRING, .protocol_id = SMB302_PROT_ID, .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES | SMB2_GLOBAL_CAP_ENCRYPTION, .large_lock_type = 0, .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, .header_size = sizeof(struct smb2_hdr), .max_header_size = MAX_SMB2_HDR_SIZE, .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, .lock_cmd = SMB2_LOCK, .cap_unix = 0, .cap_nt_find = SMB2_NT_FIND, .cap_large_files = SMB2_LARGE_FILES, .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, .create_lease_size = sizeof(struct create_lease_v2), }; #ifdef CONFIG_CIFS_SMB311 struct smb_version_values smb311_values = { .version_string = SMB311_VERSION_STRING, .protocol_id = SMB311_PROT_ID, .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES, .large_lock_type = 0, .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, .header_size = sizeof(struct smb2_hdr), .max_header_size = MAX_SMB2_HDR_SIZE, .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, .lock_cmd = SMB2_LOCK, .cap_unix = 0, .cap_nt_find = SMB2_NT_FIND, .cap_large_files = SMB2_LARGE_FILES, .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, .create_lease_size = sizeof(struct create_lease_v2), }; #endif /* SMB311 */

Overall Contributors

PersonTokensPropCommitsCommitProp
Pavel Shilovsky915664.72%6052.17%
Steve French424029.97%3933.91%
Aurelien Aptel5023.55%32.61%
Sachin S. Prabhu1731.22%86.96%
Jeff Layton400.28%10.87%
Joe Perches180.13%10.87%
David Howells150.11%10.87%
Tobias Regnery30.02%10.87%
Fabian Frederick10.01%10.87%
Total14148100.00%115100.00%
Directory: fs/cifs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.