1/* 2 * SMB2 version specific operations 3 * 4 * Copyright (c) 2012, Jeff Layton <jlayton@redhat.com> 5 * 6 * This library is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License v2 as published 8 * by the Free Software Foundation. 9 * 10 * This library is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 13 * the GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with this library; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20#include <linux/pagemap.h> 21#include <linux/vfs.h> 22#include <linux/falloc.h> 23#include "cifsglob.h" 24#include "smb2pdu.h" 25#include "smb2proto.h" 26#include "cifsproto.h" 27#include "cifs_debug.h" 28#include "cifs_unicode.h" 29#include "smb2status.h" 30#include "smb2glob.h" 31 32static int 33change_conf(struct TCP_Server_Info *server) 34{ 35 server->credits += server->echo_credits + server->oplock_credits; 36 server->oplock_credits = server->echo_credits = 0; 37 switch (server->credits) { 38 case 0: 39 return -1; 40 case 1: 41 server->echoes = false; 42 server->oplocks = false; 43 cifs_dbg(VFS, "disabling echoes and oplocks\n"); 44 break; 45 case 2: 46 server->echoes = true; 47 server->oplocks = false; 48 server->echo_credits = 1; 49 cifs_dbg(FYI, "disabling oplocks\n"); 50 break; 51 default: 52 server->echoes = true; 53 if (enable_oplocks) { 54 server->oplocks = true; 55 server->oplock_credits = 1; 56 } else 57 server->oplocks = false; 58 59 server->echo_credits = 1; 60 } 61 server->credits -= server->echo_credits + server->oplock_credits; 62 return 0; 63} 64 65static void 66smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add, 67 const int optype) 68{ 69 int *val, rc = 0; 70 spin_lock(&server->req_lock); 71 val = server->ops->get_credits_field(server, optype); 72 *val += add; 73 server->in_flight--; 74 if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP) 75 rc = change_conf(server); 76 /* 77 * Sometimes server returns 0 credits on oplock break ack - we need to 78 * rebalance credits in this case. 79 */ 80 else if (server->in_flight > 0 && server->oplock_credits == 0 && 81 server->oplocks) { 82 if (server->credits > 1) { 83 server->credits--; 84 server->oplock_credits++; 85 } 86 } 87 spin_unlock(&server->req_lock); 88 wake_up(&server->request_q); 89 if (rc) 90 cifs_reconnect(server); 91} 92 93static void 94smb2_set_credits(struct TCP_Server_Info *server, const int val) 95{ 96 spin_lock(&server->req_lock); 97 server->credits = val; 98 spin_unlock(&server->req_lock); 99} 100 101static int * 102smb2_get_credits_field(struct TCP_Server_Info *server, const int optype) 103{ 104 switch (optype) { 105 case CIFS_ECHO_OP: 106 return &server->echo_credits; 107 case CIFS_OBREAK_OP: 108 return &server->oplock_credits; 109 default: 110 return &server->credits; 111 } 112} 113 114static unsigned int 115smb2_get_credits(struct mid_q_entry *mid) 116{ 117 return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest); 118} 119 120static int 121smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size, 122 unsigned int *num, unsigned int *credits) 123{ 124 int rc = 0; 125 unsigned int scredits; 126 127 spin_lock(&server->req_lock); 128 while (1) { 129 if (server->credits <= 0) { 130 spin_unlock(&server->req_lock); 131 cifs_num_waiters_inc(server); 132 rc = wait_event_killable(server->request_q, 133 has_credits(server, &server->credits)); 134 cifs_num_waiters_dec(server); 135 if (rc) 136 return rc; 137 spin_lock(&server->req_lock); 138 } else { 139 if (server->tcpStatus == CifsExiting) { 140 spin_unlock(&server->req_lock); 141 return -ENOENT; 142 } 143 144 scredits = server->credits; 145 /* can deadlock with reopen */ 146 if (scredits == 1) { 147 *num = SMB2_MAX_BUFFER_SIZE; 148 *credits = 0; 149 break; 150 } 151 152 /* leave one credit for a possible reopen */ 153 scredits--; 154 *num = min_t(unsigned int, size, 155 scredits * SMB2_MAX_BUFFER_SIZE); 156 157 *credits = DIV_ROUND_UP(*num, SMB2_MAX_BUFFER_SIZE); 158 server->credits -= *credits; 159 server->in_flight++; 160 break; 161 } 162 } 163 spin_unlock(&server->req_lock); 164 return rc; 165} 166 167static __u64 168smb2_get_next_mid(struct TCP_Server_Info *server) 169{ 170 __u64 mid; 171 /* for SMB2 we need the current value */ 172 spin_lock(&GlobalMid_Lock); 173 mid = server->CurrentMid++; 174 spin_unlock(&GlobalMid_Lock); 175 return mid; 176} 177 178static struct mid_q_entry * 179smb2_find_mid(struct TCP_Server_Info *server, char *buf) 180{ 181 struct mid_q_entry *mid; 182 struct smb2_hdr *hdr = (struct smb2_hdr *)buf; 183 __u64 wire_mid = le64_to_cpu(hdr->MessageId); 184 185 spin_lock(&GlobalMid_Lock); 186 list_for_each_entry(mid, &server->pending_mid_q, qhead) { 187 if ((mid->mid == wire_mid) && 188 (mid->mid_state == MID_REQUEST_SUBMITTED) && 189 (mid->command == hdr->Command)) { 190 spin_unlock(&GlobalMid_Lock); 191 return mid; 192 } 193 } 194 spin_unlock(&GlobalMid_Lock); 195 return NULL; 196} 197 198static void 199smb2_dump_detail(void *buf) 200{ 201#ifdef CONFIG_CIFS_DEBUG2 202 struct smb2_hdr *smb = (struct smb2_hdr *)buf; 203 204 cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n", 205 smb->Command, smb->Status, smb->Flags, smb->MessageId, 206 smb->ProcessId); 207 cifs_dbg(VFS, "smb buf %p len %u\n", smb, smb2_calc_size(smb)); 208#endif 209} 210 211static bool 212smb2_need_neg(struct TCP_Server_Info *server) 213{ 214 return server->max_read == 0; 215} 216 217static int 218smb2_negotiate(const unsigned int xid, struct cifs_ses *ses) 219{ 220 int rc; 221 ses->server->CurrentMid = 0; 222 rc = SMB2_negotiate(xid, ses); 223 /* BB we probably don't need to retry with modern servers */ 224 if (rc == -EAGAIN) 225 rc = -EHOSTDOWN; 226 return rc; 227} 228 229static unsigned int 230smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info) 231{ 232 struct TCP_Server_Info *server = tcon->ses->server; 233 unsigned int wsize; 234 235 /* start with specified wsize, or default */ 236 wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE; 237 wsize = min_t(unsigned int, wsize, server->max_write); 238 239 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU)) 240 wsize = min_t(unsigned int, wsize, SMB2_MAX_BUFFER_SIZE); 241 242 return wsize; 243} 244 245static unsigned int 246smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info) 247{ 248 struct TCP_Server_Info *server = tcon->ses->server; 249 unsigned int rsize; 250 251 /* start with specified rsize, or default */ 252 rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE; 253 rsize = min_t(unsigned int, rsize, server->max_read); 254 255 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU)) 256 rsize = min_t(unsigned int, rsize, SMB2_MAX_BUFFER_SIZE); 257 258 return rsize; 259} 260 261#ifdef CONFIG_CIFS_STATS2 262static int 263SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon) 264{ 265 int rc; 266 unsigned int ret_data_len = 0; 267 struct network_interface_info_ioctl_rsp *out_buf; 268 269 rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, 270 FSCTL_QUERY_NETWORK_INTERFACE_INFO, true /* is_fsctl */, 271 NULL /* no data input */, 0 /* no data input */, 272 (char **)&out_buf, &ret_data_len); 273 if (rc != 0) 274 cifs_dbg(VFS, "error %d on ioctl to get interface list\n", rc); 275 else if (ret_data_len < sizeof(struct network_interface_info_ioctl_rsp)) { 276 cifs_dbg(VFS, "server returned bad net interface info buf\n"); 277 rc = -EINVAL; 278 } else { 279 /* Dump info on first interface */ 280 cifs_dbg(FYI, "Adapter Capability 0x%x\t", 281 le32_to_cpu(out_buf->Capability)); 282 cifs_dbg(FYI, "Link Speed %lld\n", 283 le64_to_cpu(out_buf->LinkSpeed)); 284 } 285 286 return rc; 287} 288#endif /* STATS2 */ 289 290static void 291smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon) 292{ 293 int rc; 294 __le16 srch_path = 0; /* Null - open root of share */ 295 u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 296 struct cifs_open_parms oparms; 297 struct cifs_fid fid; 298 299 oparms.tcon = tcon; 300 oparms.desired_access = FILE_READ_ATTRIBUTES; 301 oparms.disposition = FILE_OPEN; 302 oparms.create_options = 0; 303 oparms.fid = &fid; 304 oparms.reconnect = false; 305 306 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL); 307 if (rc) 308 return; 309 310#ifdef CONFIG_CIFS_STATS2 311 SMB3_request_interfaces(xid, tcon); 312#endif /* STATS2 */ 313 314 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, 315 FS_ATTRIBUTE_INFORMATION); 316 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, 317 FS_DEVICE_INFORMATION); 318 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, 319 FS_SECTOR_SIZE_INFORMATION); /* SMB3 specific */ 320 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 321 return; 322} 323 324static void 325smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon) 326{ 327 int rc; 328 __le16 srch_path = 0; /* Null - open root of share */ 329 u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 330 struct cifs_open_parms oparms; 331 struct cifs_fid fid; 332 333 oparms.tcon = tcon; 334 oparms.desired_access = FILE_READ_ATTRIBUTES; 335 oparms.disposition = FILE_OPEN; 336 oparms.create_options = 0; 337 oparms.fid = &fid; 338 oparms.reconnect = false; 339 340 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL); 341 if (rc) 342 return; 343 344 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, 345 FS_ATTRIBUTE_INFORMATION); 346 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, 347 FS_DEVICE_INFORMATION); 348 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 349 return; 350} 351 352static int 353smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon, 354 struct cifs_sb_info *cifs_sb, const char *full_path) 355{ 356 int rc; 357 __le16 *utf16_path; 358 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 359 struct cifs_open_parms oparms; 360 struct cifs_fid fid; 361 362 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb); 363 if (!utf16_path) 364 return -ENOMEM; 365 366 oparms.tcon = tcon; 367 oparms.desired_access = FILE_READ_ATTRIBUTES; 368 oparms.disposition = FILE_OPEN; 369 oparms.create_options = 0; 370 oparms.fid = &fid; 371 oparms.reconnect = false; 372 373 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL); 374 if (rc) { 375 kfree(utf16_path); 376 return rc; 377 } 378 379 rc = SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 380 kfree(utf16_path); 381 return rc; 382} 383 384static int 385smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon, 386 struct cifs_sb_info *cifs_sb, const char *full_path, 387 u64 *uniqueid, FILE_ALL_INFO *data) 388{ 389 *uniqueid = le64_to_cpu(data->IndexNumber); 390 return 0; 391} 392 393static int 394smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon, 395 struct cifs_fid *fid, FILE_ALL_INFO *data) 396{ 397 int rc; 398 struct smb2_file_all_info *smb2_data; 399 400 smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2, 401 GFP_KERNEL); 402 if (smb2_data == NULL) 403 return -ENOMEM; 404 405 rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid, 406 smb2_data); 407 if (!rc) 408 move_smb2_info_to_cifs(data, smb2_data); 409 kfree(smb2_data); 410 return rc; 411} 412 413static bool 414smb2_can_echo(struct TCP_Server_Info *server) 415{ 416 return server->echoes; 417} 418 419static void 420smb2_clear_stats(struct cifs_tcon *tcon) 421{ 422#ifdef CONFIG_CIFS_STATS 423 int i; 424 for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) { 425 atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0); 426 atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0); 427 } 428#endif 429} 430 431static void 432smb2_dump_share_caps(struct seq_file *m, struct cifs_tcon *tcon) 433{ 434 seq_puts(m, "\n\tShare Capabilities:"); 435 if (tcon->capabilities & SMB2_SHARE_CAP_DFS) 436 seq_puts(m, " DFS,"); 437 if (tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY) 438 seq_puts(m, " CONTINUOUS AVAILABILITY,"); 439 if (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT) 440 seq_puts(m, " SCALEOUT,"); 441 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) 442 seq_puts(m, " CLUSTER,"); 443 if (tcon->capabilities & SMB2_SHARE_CAP_ASYMMETRIC) 444 seq_puts(m, " ASYMMETRIC,"); 445 if (tcon->capabilities == 0) 446 seq_puts(m, " None"); 447 if (tcon->ss_flags & SSINFO_FLAGS_ALIGNED_DEVICE) 448 seq_puts(m, " Aligned,"); 449 if (tcon->ss_flags & SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE) 450 seq_puts(m, " Partition Aligned,"); 451 if (tcon->ss_flags & SSINFO_FLAGS_NO_SEEK_PENALTY) 452 seq_puts(m, " SSD,"); 453 if (tcon->ss_flags & SSINFO_FLAGS_TRIM_ENABLED) 454 seq_puts(m, " TRIM-support,"); 455 456 seq_printf(m, "\tShare Flags: 0x%x", tcon->share_flags); 457 if (tcon->perf_sector_size) 458 seq_printf(m, "\tOptimal sector size: 0x%x", 459 tcon->perf_sector_size); 460} 461 462static void 463smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon) 464{ 465#ifdef CONFIG_CIFS_STATS 466 atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent; 467 atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed; 468 seq_printf(m, "\nNegotiates: %d sent %d failed", 469 atomic_read(&sent[SMB2_NEGOTIATE_HE]), 470 atomic_read(&failed[SMB2_NEGOTIATE_HE])); 471 seq_printf(m, "\nSessionSetups: %d sent %d failed", 472 atomic_read(&sent[SMB2_SESSION_SETUP_HE]), 473 atomic_read(&failed[SMB2_SESSION_SETUP_HE])); 474 seq_printf(m, "\nLogoffs: %d sent %d failed", 475 atomic_read(&sent[SMB2_LOGOFF_HE]), 476 atomic_read(&failed[SMB2_LOGOFF_HE])); 477 seq_printf(m, "\nTreeConnects: %d sent %d failed", 478 atomic_read(&sent[SMB2_TREE_CONNECT_HE]), 479 atomic_read(&failed[SMB2_TREE_CONNECT_HE])); 480 seq_printf(m, "\nTreeDisconnects: %d sent %d failed", 481 atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]), 482 atomic_read(&failed[SMB2_TREE_DISCONNECT_HE])); 483 seq_printf(m, "\nCreates: %d sent %d failed", 484 atomic_read(&sent[SMB2_CREATE_HE]), 485 atomic_read(&failed[SMB2_CREATE_HE])); 486 seq_printf(m, "\nCloses: %d sent %d failed", 487 atomic_read(&sent[SMB2_CLOSE_HE]), 488 atomic_read(&failed[SMB2_CLOSE_HE])); 489 seq_printf(m, "\nFlushes: %d sent %d failed", 490 atomic_read(&sent[SMB2_FLUSH_HE]), 491 atomic_read(&failed[SMB2_FLUSH_HE])); 492 seq_printf(m, "\nReads: %d sent %d failed", 493 atomic_read(&sent[SMB2_READ_HE]), 494 atomic_read(&failed[SMB2_READ_HE])); 495 seq_printf(m, "\nWrites: %d sent %d failed", 496 atomic_read(&sent[SMB2_WRITE_HE]), 497 atomic_read(&failed[SMB2_WRITE_HE])); 498 seq_printf(m, "\nLocks: %d sent %d failed", 499 atomic_read(&sent[SMB2_LOCK_HE]), 500 atomic_read(&failed[SMB2_LOCK_HE])); 501 seq_printf(m, "\nIOCTLs: %d sent %d failed", 502 atomic_read(&sent[SMB2_IOCTL_HE]), 503 atomic_read(&failed[SMB2_IOCTL_HE])); 504 seq_printf(m, "\nCancels: %d sent %d failed", 505 atomic_read(&sent[SMB2_CANCEL_HE]), 506 atomic_read(&failed[SMB2_CANCEL_HE])); 507 seq_printf(m, "\nEchos: %d sent %d failed", 508 atomic_read(&sent[SMB2_ECHO_HE]), 509 atomic_read(&failed[SMB2_ECHO_HE])); 510 seq_printf(m, "\nQueryDirectories: %d sent %d failed", 511 atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]), 512 atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE])); 513 seq_printf(m, "\nChangeNotifies: %d sent %d failed", 514 atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]), 515 atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE])); 516 seq_printf(m, "\nQueryInfos: %d sent %d failed", 517 atomic_read(&sent[SMB2_QUERY_INFO_HE]), 518 atomic_read(&failed[SMB2_QUERY_INFO_HE])); 519 seq_printf(m, "\nSetInfos: %d sent %d failed", 520 atomic_read(&sent[SMB2_SET_INFO_HE]), 521 atomic_read(&failed[SMB2_SET_INFO_HE])); 522 seq_printf(m, "\nOplockBreaks: %d sent %d failed", 523 atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]), 524 atomic_read(&failed[SMB2_OPLOCK_BREAK_HE])); 525#endif 526} 527 528static void 529smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock) 530{ 531 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 532 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 533 534 cfile->fid.persistent_fid = fid->persistent_fid; 535 cfile->fid.volatile_fid = fid->volatile_fid; 536 server->ops->set_oplock_level(cinode, oplock, fid->epoch, 537 &fid->purge_cache); 538 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode); 539} 540 541static void 542smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon, 543 struct cifs_fid *fid) 544{ 545 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid); 546} 547 548static int 549SMB2_request_res_key(const unsigned int xid, struct cifs_tcon *tcon, 550 u64 persistent_fid, u64 volatile_fid, 551 struct copychunk_ioctl *pcchunk) 552{ 553 int rc; 554 unsigned int ret_data_len; 555 struct resume_key_req *res_key; 556 557 rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid, 558 FSCTL_SRV_REQUEST_RESUME_KEY, true /* is_fsctl */, 559 NULL, 0 /* no input */, 560 (char **)&res_key, &ret_data_len); 561 562 if (rc) { 563 cifs_dbg(VFS, "refcpy ioctl error %d getting resume key\n", rc); 564 goto req_res_key_exit; 565 } 566 if (ret_data_len < sizeof(struct resume_key_req)) { 567 cifs_dbg(VFS, "Invalid refcopy resume key length\n"); 568 rc = -EINVAL; 569 goto req_res_key_exit; 570 } 571 memcpy(pcchunk->SourceKey, res_key->ResumeKey, COPY_CHUNK_RES_KEY_SIZE); 572 573req_res_key_exit: 574 kfree(res_key); 575 return rc; 576} 577 578static int 579smb2_clone_range(const unsigned int xid, 580 struct cifsFileInfo *srcfile, 581 struct cifsFileInfo *trgtfile, u64 src_off, 582 u64 len, u64 dest_off) 583{ 584 int rc; 585 unsigned int ret_data_len; 586 struct copychunk_ioctl *pcchunk; 587 struct copychunk_ioctl_rsp *retbuf = NULL; 588 struct cifs_tcon *tcon; 589 int chunks_copied = 0; 590 bool chunk_sizes_updated = false; 591 592 pcchunk = kmalloc(sizeof(struct copychunk_ioctl), GFP_KERNEL); 593 594 if (pcchunk == NULL) 595 return -ENOMEM; 596 597 cifs_dbg(FYI, "in smb2_clone_range - about to call request res key\n"); 598 /* Request a key from the server to identify the source of the copy */ 599 rc = SMB2_request_res_key(xid, tlink_tcon(srcfile->tlink), 600 srcfile->fid.persistent_fid, 601 srcfile->fid.volatile_fid, pcchunk); 602 603 /* Note: request_res_key sets res_key null only if rc !=0 */ 604 if (rc) 605 goto cchunk_out; 606 607 /* For now array only one chunk long, will make more flexible later */ 608 pcchunk->ChunkCount = cpu_to_le32(1); 609 pcchunk->Reserved = 0; 610 pcchunk->Reserved2 = 0; 611 612 tcon = tlink_tcon(trgtfile->tlink); 613 614 while (len > 0) { 615 pcchunk->SourceOffset = cpu_to_le64(src_off); 616 pcchunk->TargetOffset = cpu_to_le64(dest_off); 617 pcchunk->Length = 618 cpu_to_le32(min_t(u32, len, tcon->max_bytes_chunk)); 619 620 /* Request server copy to target from src identified by key */ 621 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid, 622 trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE, 623 true /* is_fsctl */, (char *)pcchunk, 624 sizeof(struct copychunk_ioctl), (char **)&retbuf, 625 &ret_data_len); 626 if (rc == 0) { 627 if (ret_data_len != 628 sizeof(struct copychunk_ioctl_rsp)) { 629 cifs_dbg(VFS, "invalid cchunk response size\n"); 630 rc = -EIO; 631 goto cchunk_out; 632 } 633 if (retbuf->TotalBytesWritten == 0) { 634 cifs_dbg(FYI, "no bytes copied\n"); 635 rc = -EIO; 636 goto cchunk_out; 637 } 638 /* 639 * Check if server claimed to write more than we asked 640 */ 641 if (le32_to_cpu(retbuf->TotalBytesWritten) > 642 le32_to_cpu(pcchunk->Length)) { 643 cifs_dbg(VFS, "invalid copy chunk response\n"); 644 rc = -EIO; 645 goto cchunk_out; 646 } 647 if (le32_to_cpu(retbuf->ChunksWritten) != 1) { 648 cifs_dbg(VFS, "invalid num chunks written\n"); 649 rc = -EIO; 650 goto cchunk_out; 651 } 652 chunks_copied++; 653 654 src_off += le32_to_cpu(retbuf->TotalBytesWritten); 655 dest_off += le32_to_cpu(retbuf->TotalBytesWritten); 656 len -= le32_to_cpu(retbuf->TotalBytesWritten); 657 658 cifs_dbg(FYI, "Chunks %d PartialChunk %d Total %d\n", 659 le32_to_cpu(retbuf->ChunksWritten), 660 le32_to_cpu(retbuf->ChunkBytesWritten), 661 le32_to_cpu(retbuf->TotalBytesWritten)); 662 } else if (rc == -EINVAL) { 663 if (ret_data_len != sizeof(struct copychunk_ioctl_rsp)) 664 goto cchunk_out; 665 666 cifs_dbg(FYI, "MaxChunks %d BytesChunk %d MaxCopy %d\n", 667 le32_to_cpu(retbuf->ChunksWritten), 668 le32_to_cpu(retbuf->ChunkBytesWritten), 669 le32_to_cpu(retbuf->TotalBytesWritten)); 670 671 /* 672 * Check if this is the first request using these sizes, 673 * (ie check if copy succeed once with original sizes 674 * and check if the server gave us different sizes after 675 * we already updated max sizes on previous request). 676 * if not then why is the server returning an error now 677 */ 678 if ((chunks_copied != 0) || chunk_sizes_updated) 679 goto cchunk_out; 680 681 /* Check that server is not asking us to grow size */ 682 if (le32_to_cpu(retbuf->ChunkBytesWritten) < 683 tcon->max_bytes_chunk) 684 tcon->max_bytes_chunk = 685 le32_to_cpu(retbuf->ChunkBytesWritten); 686 else 687 goto cchunk_out; /* server gave us bogus size */ 688 689 /* No need to change MaxChunks since already set to 1 */ 690 chunk_sizes_updated = true; 691 } else 692 goto cchunk_out; 693 } 694 695cchunk_out: 696 kfree(pcchunk); 697 return rc; 698} 699 700static int 701smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon, 702 struct cifs_fid *fid) 703{ 704 return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid); 705} 706 707static unsigned int 708smb2_read_data_offset(char *buf) 709{ 710 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf; 711 return rsp->DataOffset; 712} 713 714static unsigned int 715smb2_read_data_length(char *buf) 716{ 717 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf; 718 return le32_to_cpu(rsp->DataLength); 719} 720 721 722static int 723smb2_sync_read(const unsigned int xid, struct cifs_fid *pfid, 724 struct cifs_io_parms *parms, unsigned int *bytes_read, 725 char **buf, int *buf_type) 726{ 727 parms->persistent_fid = pfid->persistent_fid; 728 parms->volatile_fid = pfid->volatile_fid; 729 return SMB2_read(xid, parms, bytes_read, buf, buf_type); 730} 731 732static int 733smb2_sync_write(const unsigned int xid, struct cifs_fid *pfid, 734 struct cifs_io_parms *parms, unsigned int *written, 735 struct kvec *iov, unsigned long nr_segs) 736{ 737 738 parms->persistent_fid = pfid->persistent_fid; 739 parms->volatile_fid = pfid->volatile_fid; 740 return SMB2_write(xid, parms, written, iov, nr_segs); 741} 742 743/* Set or clear the SPARSE_FILE attribute based on value passed in setsparse */ 744static bool smb2_set_sparse(const unsigned int xid, struct cifs_tcon *tcon, 745 struct cifsFileInfo *cfile, struct inode *inode, __u8 setsparse) 746{ 747 struct cifsInodeInfo *cifsi; 748 int rc; 749 750 cifsi = CIFS_I(inode); 751 752 /* if file already sparse don't bother setting sparse again */ 753 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && setsparse) 754 return true; /* already sparse */ 755 756 if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) && !setsparse) 757 return true; /* already not sparse */ 758 759 /* 760 * Can't check for sparse support on share the usual way via the 761 * FS attribute info (FILE_SUPPORTS_SPARSE_FILES) on the share 762 * since Samba server doesn't set the flag on the share, yet 763 * supports the set sparse FSCTL and returns sparse correctly 764 * in the file attributes. If we fail setting sparse though we 765 * mark that server does not support sparse files for this share 766 * to avoid repeatedly sending the unsupported fsctl to server 767 * if the file is repeatedly extended. 768 */ 769 if (tcon->broken_sparse_sup) 770 return false; 771 772 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 773 cfile->fid.volatile_fid, FSCTL_SET_SPARSE, 774 true /* is_fctl */, &setsparse, 1, NULL, NULL); 775 if (rc) { 776 tcon->broken_sparse_sup = true; 777 cifs_dbg(FYI, "set sparse rc = %d\n", rc); 778 return false; 779 } 780 781 if (setsparse) 782 cifsi->cifsAttrs |= FILE_ATTRIBUTE_SPARSE_FILE; 783 else 784 cifsi->cifsAttrs &= (~FILE_ATTRIBUTE_SPARSE_FILE); 785 786 return true; 787} 788 789static int 790smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon, 791 struct cifsFileInfo *cfile, __u64 size, bool set_alloc) 792{ 793 __le64 eof = cpu_to_le64(size); 794 struct inode *inode; 795 796 /* 797 * If extending file more than one page make sparse. Many Linux fs 798 * make files sparse by default when extending via ftruncate 799 */ 800 inode = d_inode(cfile->dentry); 801 802 if (!set_alloc && (size > inode->i_size + 8192)) { 803 __u8 set_sparse = 1; 804 805 /* whether set sparse succeeds or not, extend the file */ 806 smb2_set_sparse(xid, tcon, cfile, inode, set_sparse); 807 } 808 809 return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid, 810 cfile->fid.volatile_fid, cfile->pid, &eof, false); 811} 812 813static int 814smb2_duplicate_extents(const unsigned int xid, 815 struct cifsFileInfo *srcfile, 816 struct cifsFileInfo *trgtfile, u64 src_off, 817 u64 len, u64 dest_off) 818{ 819 int rc; 820 unsigned int ret_data_len; 821 char *retbuf = NULL; 822 struct duplicate_extents_to_file dup_ext_buf; 823 struct cifs_tcon *tcon = tlink_tcon(trgtfile->tlink); 824 825 /* server fileays advertise duplicate extent support with this flag */ 826 if ((le32_to_cpu(tcon->fsAttrInfo.Attributes) & 827 FILE_SUPPORTS_BLOCK_REFCOUNTING) == 0) 828 return -EOPNOTSUPP; 829 830 dup_ext_buf.VolatileFileHandle = srcfile->fid.volatile_fid; 831 dup_ext_buf.PersistentFileHandle = srcfile->fid.persistent_fid; 832 dup_ext_buf.SourceFileOffset = cpu_to_le64(src_off); 833 dup_ext_buf.TargetFileOffset = cpu_to_le64(dest_off); 834 dup_ext_buf.ByteCount = cpu_to_le64(len); 835 cifs_dbg(FYI, "duplicate extents: src off %lld dst off %lld len %lld", 836 src_off, dest_off, len); 837 838 rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false); 839 if (rc) 840 goto duplicate_extents_out; 841 842 rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid, 843 trgtfile->fid.volatile_fid, 844 FSCTL_DUPLICATE_EXTENTS_TO_FILE, 845 true /* is_fsctl */, (char *)&dup_ext_buf, 846 sizeof(struct duplicate_extents_to_file), 847 (char **)&retbuf, 848 &ret_data_len); 849 850 if (ret_data_len > 0) 851 cifs_dbg(FYI, "non-zero response length in duplicate extents"); 852 853duplicate_extents_out: 854 return rc; 855} 856 857static int 858smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon, 859 struct cifsFileInfo *cfile) 860{ 861 return SMB2_set_compression(xid, tcon, cfile->fid.persistent_fid, 862 cfile->fid.volatile_fid); 863} 864 865static int 866smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon, 867 struct cifsFileInfo *cfile) 868{ 869 struct fsctl_set_integrity_information_req integr_info; 870 char *retbuf = NULL; 871 unsigned int ret_data_len; 872 873 integr_info.ChecksumAlgorithm = cpu_to_le16(CHECKSUM_TYPE_UNCHANGED); 874 integr_info.Flags = 0; 875 integr_info.Reserved = 0; 876 877 return SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 878 cfile->fid.volatile_fid, 879 FSCTL_SET_INTEGRITY_INFORMATION, 880 true /* is_fsctl */, (char *)&integr_info, 881 sizeof(struct fsctl_set_integrity_information_req), 882 (char **)&retbuf, 883 &ret_data_len); 884 885} 886 887static int 888smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon, 889 const char *path, struct cifs_sb_info *cifs_sb, 890 struct cifs_fid *fid, __u16 search_flags, 891 struct cifs_search_info *srch_inf) 892{ 893 __le16 *utf16_path; 894 int rc; 895 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 896 struct cifs_open_parms oparms; 897 898 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb); 899 if (!utf16_path) 900 return -ENOMEM; 901 902 oparms.tcon = tcon; 903 oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA; 904 oparms.disposition = FILE_OPEN; 905 oparms.create_options = 0; 906 oparms.fid = fid; 907 oparms.reconnect = false; 908 909 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL); 910 kfree(utf16_path); 911 if (rc) { 912 cifs_dbg(VFS, "open dir failed\n"); 913 return rc; 914 } 915 916 srch_inf->entries_in_buffer = 0; 917 srch_inf->index_of_last_entry = 0; 918 919 rc = SMB2_query_directory(xid, tcon, fid->persistent_fid, 920 fid->volatile_fid, 0, srch_inf); 921 if (rc) { 922 cifs_dbg(VFS, "query directory failed\n"); 923 SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid); 924 } 925 return rc; 926} 927 928static int 929smb2_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon, 930 struct cifs_fid *fid, __u16 search_flags, 931 struct cifs_search_info *srch_inf) 932{ 933 return SMB2_query_directory(xid, tcon, fid->persistent_fid, 934 fid->volatile_fid, 0, srch_inf); 935} 936 937static int 938smb2_close_dir(const unsigned int xid, struct cifs_tcon *tcon, 939 struct cifs_fid *fid) 940{ 941 return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid); 942} 943 944/* 945* If we negotiate SMB2 protocol and get STATUS_PENDING - update 946* the number of credits and return true. Otherwise - return false. 947*/ 948static bool 949smb2_is_status_pending(char *buf, struct TCP_Server_Info *server, int length) 950{ 951 struct smb2_hdr *hdr = (struct smb2_hdr *)buf; 952 953 if (hdr->Status != STATUS_PENDING) 954 return false; 955 956 if (!length) { 957 spin_lock(&server->req_lock); 958 server->credits += le16_to_cpu(hdr->CreditRequest); 959 spin_unlock(&server->req_lock); 960 wake_up(&server->request_q); 961 } 962 963 return true; 964} 965 966static int 967smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid, 968 struct cifsInodeInfo *cinode) 969{ 970 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING) 971 return SMB2_lease_break(0, tcon, cinode->lease_key, 972 smb2_get_lease_state(cinode)); 973 974 return SMB2_oplock_break(0, tcon, fid->persistent_fid, 975 fid->volatile_fid, 976 CIFS_CACHE_READ(cinode) ? 1 : 0); 977} 978 979static int 980smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon, 981 struct kstatfs *buf) 982{ 983 int rc; 984 __le16 srch_path = 0; /* Null - open root of share */ 985 u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 986 struct cifs_open_parms oparms; 987 struct cifs_fid fid; 988 989 oparms.tcon = tcon; 990 oparms.desired_access = FILE_READ_ATTRIBUTES; 991 oparms.disposition = FILE_OPEN; 992 oparms.create_options = 0; 993 oparms.fid = &fid; 994 oparms.reconnect = false; 995 996 rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL); 997 if (rc) 998 return rc; 999 buf->f_type = SMB2_MAGIC_NUMBER; 1000 rc = SMB2_QFS_info(xid, tcon, fid.persistent_fid, fid.volatile_fid, 1001 buf); 1002 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 1003 return rc; 1004} 1005 1006static bool 1007smb2_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2) 1008{ 1009 return ob1->fid.persistent_fid == ob2->fid.persistent_fid && 1010 ob1->fid.volatile_fid == ob2->fid.volatile_fid; 1011} 1012 1013static int 1014smb2_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset, 1015 __u64 length, __u32 type, int lock, int unlock, bool wait) 1016{ 1017 if (unlock && !lock) 1018 type = SMB2_LOCKFLAG_UNLOCK; 1019 return SMB2_lock(xid, tlink_tcon(cfile->tlink), 1020 cfile->fid.persistent_fid, cfile->fid.volatile_fid, 1021 current->tgid, length, offset, type, wait); 1022} 1023 1024static void 1025smb2_get_lease_key(struct inode *inode, struct cifs_fid *fid) 1026{ 1027 memcpy(fid->lease_key, CIFS_I(inode)->lease_key, SMB2_LEASE_KEY_SIZE); 1028} 1029 1030static void 1031smb2_set_lease_key(struct inode *inode, struct cifs_fid *fid) 1032{ 1033 memcpy(CIFS_I(inode)->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE); 1034} 1035 1036static void 1037smb2_new_lease_key(struct cifs_fid *fid) 1038{ 1039 get_random_bytes(fid->lease_key, SMB2_LEASE_KEY_SIZE); 1040} 1041 1042static int 1043smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, 1044 const char *full_path, char **target_path, 1045 struct cifs_sb_info *cifs_sb) 1046{ 1047 int rc; 1048 __le16 *utf16_path; 1049 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 1050 struct cifs_open_parms oparms; 1051 struct cifs_fid fid; 1052 struct smb2_err_rsp *err_buf = NULL; 1053 struct smb2_symlink_err_rsp *symlink; 1054 unsigned int sub_len, sub_offset; 1055 1056 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path); 1057 1058 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb); 1059 if (!utf16_path) 1060 return -ENOMEM; 1061 1062 oparms.tcon = tcon; 1063 oparms.desired_access = FILE_READ_ATTRIBUTES; 1064 oparms.disposition = FILE_OPEN; 1065 oparms.create_options = 0; 1066 oparms.fid = &fid; 1067 oparms.reconnect = false; 1068 1069 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_buf); 1070 1071 if (!rc || !err_buf) { 1072 kfree(utf16_path); 1073 return -ENOENT; 1074 } 1075 /* open must fail on symlink - reset rc */ 1076 rc = 0; 1077 symlink = (struct smb2_symlink_err_rsp *)err_buf->ErrorData; 1078 sub_len = le16_to_cpu(symlink->SubstituteNameLength); 1079 sub_offset = le16_to_cpu(symlink->SubstituteNameOffset); 1080 *target_path = cifs_strndup_from_utf16( 1081 (char *)symlink->PathBuffer + sub_offset, 1082 sub_len, true, cifs_sb->local_nls); 1083 if (!(*target_path)) { 1084 kfree(utf16_path); 1085 return -ENOMEM; 1086 } 1087 convert_delimiter(*target_path, '/'); 1088 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path); 1089 kfree(utf16_path); 1090 return rc; 1091} 1092 1093static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon, 1094 loff_t offset, loff_t len, bool keep_size) 1095{ 1096 struct inode *inode; 1097 struct cifsInodeInfo *cifsi; 1098 struct cifsFileInfo *cfile = file->private_data; 1099 struct file_zero_data_information fsctl_buf; 1100 long rc; 1101 unsigned int xid; 1102 1103 xid = get_xid(); 1104 1105 inode = d_inode(cfile->dentry); 1106 cifsi = CIFS_I(inode); 1107 1108 /* if file not oplocked can't be sure whether asking to extend size */ 1109 if (!CIFS_CACHE_READ(cifsi)) 1110 if (keep_size == false) 1111 return -EOPNOTSUPP; 1112 1113 /* 1114 * Must check if file sparse since fallocate -z (zero range) assumes 1115 * non-sparse allocation 1116 */ 1117 if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)) 1118 return -EOPNOTSUPP; 1119 1120 /* 1121 * need to make sure we are not asked to extend the file since the SMB3 1122 * fsctl does not change the file size. In the future we could change 1123 * this to zero the first part of the range then set the file size 1124 * which for a non sparse file would zero the newly extended range 1125 */ 1126 if (keep_size == false) 1127 if (i_size_read(inode) < offset + len) 1128 return -EOPNOTSUPP; 1129 1130 cifs_dbg(FYI, "offset %lld len %lld", offset, len); 1131 1132 fsctl_buf.FileOffset = cpu_to_le64(offset); 1133 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); 1134 1135 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 1136 cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, 1137 true /* is_fctl */, (char *)&fsctl_buf, 1138 sizeof(struct file_zero_data_information), NULL, NULL); 1139 free_xid(xid); 1140 return rc; 1141} 1142 1143static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon, 1144 loff_t offset, loff_t len) 1145{ 1146 struct inode *inode; 1147 struct cifsInodeInfo *cifsi; 1148 struct cifsFileInfo *cfile = file->private_data; 1149 struct file_zero_data_information fsctl_buf; 1150 long rc; 1151 unsigned int xid; 1152 __u8 set_sparse = 1; 1153 1154 xid = get_xid(); 1155 1156 inode = d_inode(cfile->dentry); 1157 cifsi = CIFS_I(inode); 1158 1159 /* Need to make file sparse, if not already, before freeing range. */ 1160 /* Consider adding equivalent for compressed since it could also work */ 1161 if (!smb2_set_sparse(xid, tcon, cfile, inode, set_sparse)) 1162 return -EOPNOTSUPP; 1163 1164 cifs_dbg(FYI, "offset %lld len %lld", offset, len); 1165 1166 fsctl_buf.FileOffset = cpu_to_le64(offset); 1167 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); 1168 1169 rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 1170 cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, 1171 true /* is_fctl */, (char *)&fsctl_buf, 1172 sizeof(struct file_zero_data_information), NULL, NULL); 1173 free_xid(xid); 1174 return rc; 1175} 1176 1177static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon, 1178 loff_t off, loff_t len, bool keep_size) 1179{ 1180 struct inode *inode; 1181 struct cifsInodeInfo *cifsi; 1182 struct cifsFileInfo *cfile = file->private_data; 1183 long rc = -EOPNOTSUPP; 1184 unsigned int xid; 1185 1186 xid = get_xid(); 1187 1188 inode = d_inode(cfile->dentry); 1189 cifsi = CIFS_I(inode); 1190 1191 /* if file not oplocked can't be sure whether asking to extend size */ 1192 if (!CIFS_CACHE_READ(cifsi)) 1193 if (keep_size == false) 1194 return -EOPNOTSUPP; 1195 1196 /* 1197 * Files are non-sparse by default so falloc may be a no-op 1198 * Must check if file sparse. If not sparse, and not extending 1199 * then no need to do anything since file already allocated 1200 */ 1201 if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) == 0) { 1202 if (keep_size == true) 1203 return 0; 1204 /* check if extending file */ 1205 else if (i_size_read(inode) >= off + len) 1206 /* not extending file and already not sparse */ 1207 return 0; 1208 /* BB: in future add else clause to extend file */ 1209 else 1210 return -EOPNOTSUPP; 1211 } 1212 1213 if ((keep_size == true) || (i_size_read(inode) >= off + len)) { 1214 /* 1215 * Check if falloc starts within first few pages of file 1216 * and ends within a few pages of the end of file to 1217 * ensure that most of file is being forced to be 1218 * fallocated now. If so then setting whole file sparse 1219 * ie potentially making a few extra pages at the beginning 1220 * or end of the file non-sparse via set_sparse is harmless. 1221 */ 1222 if ((off > 8192) || (off + len + 8192 < i_size_read(inode))) 1223 return -EOPNOTSUPP; 1224 1225 rc = smb2_set_sparse(xid, tcon, cfile, inode, false); 1226 } 1227 /* BB: else ... in future add code to extend file and set sparse */ 1228 1229 1230 free_xid(xid); 1231 return rc; 1232} 1233 1234 1235static long smb3_fallocate(struct file *file, struct cifs_tcon *tcon, int mode, 1236 loff_t off, loff_t len) 1237{ 1238 /* KEEP_SIZE already checked for by do_fallocate */ 1239 if (mode & FALLOC_FL_PUNCH_HOLE) 1240 return smb3_punch_hole(file, tcon, off, len); 1241 else if (mode & FALLOC_FL_ZERO_RANGE) { 1242 if (mode & FALLOC_FL_KEEP_SIZE) 1243 return smb3_zero_range(file, tcon, off, len, true); 1244 return smb3_zero_range(file, tcon, off, len, false); 1245 } else if (mode == FALLOC_FL_KEEP_SIZE) 1246 return smb3_simple_falloc(file, tcon, off, len, true); 1247 else if (mode == 0) 1248 return smb3_simple_falloc(file, tcon, off, len, false); 1249 1250 return -EOPNOTSUPP; 1251} 1252 1253static void 1254smb2_downgrade_oplock(struct TCP_Server_Info *server, 1255 struct cifsInodeInfo *cinode, bool set_level2) 1256{ 1257 if (set_level2) 1258 server->ops->set_oplock_level(cinode, SMB2_OPLOCK_LEVEL_II, 1259 0, NULL); 1260 else 1261 server->ops->set_oplock_level(cinode, 0, 0, NULL); 1262} 1263 1264static void 1265smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock, 1266 unsigned int epoch, bool *purge_cache) 1267{ 1268 oplock &= 0xFF; 1269 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE) 1270 return; 1271 if (oplock == SMB2_OPLOCK_LEVEL_BATCH) { 1272 cinode->oplock = CIFS_CACHE_RHW_FLG; 1273 cifs_dbg(FYI, "Batch Oplock granted on inode %p\n", 1274 &cinode->vfs_inode); 1275 } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) { 1276 cinode->oplock = CIFS_CACHE_RW_FLG; 1277 cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n", 1278 &cinode->vfs_inode); 1279 } else if (oplock == SMB2_OPLOCK_LEVEL_II) { 1280 cinode->oplock = CIFS_CACHE_READ_FLG; 1281 cifs_dbg(FYI, "Level II Oplock granted on inode %p\n", 1282 &cinode->vfs_inode); 1283 } else 1284 cinode->oplock = 0; 1285} 1286 1287static void 1288smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock, 1289 unsigned int epoch, bool *purge_cache) 1290{ 1291 char message[5] = {0}; 1292 1293 oplock &= 0xFF; 1294 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE) 1295 return; 1296 1297 cinode->oplock = 0; 1298 if (oplock & SMB2_LEASE_READ_CACHING_HE) { 1299 cinode->oplock |= CIFS_CACHE_READ_FLG; 1300 strcat(message, "R"); 1301 } 1302 if (oplock & SMB2_LEASE_HANDLE_CACHING_HE) { 1303 cinode->oplock |= CIFS_CACHE_HANDLE_FLG; 1304 strcat(message, "H"); 1305 } 1306 if (oplock & SMB2_LEASE_WRITE_CACHING_HE) { 1307 cinode->oplock |= CIFS_CACHE_WRITE_FLG; 1308 strcat(message, "W"); 1309 } 1310 if (!cinode->oplock) 1311 strcat(message, "None"); 1312 cifs_dbg(FYI, "%s Lease granted on inode %p\n", message, 1313 &cinode->vfs_inode); 1314} 1315 1316static void 1317smb3_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock, 1318 unsigned int epoch, bool *purge_cache) 1319{ 1320 unsigned int old_oplock = cinode->oplock; 1321 1322 smb21_set_oplock_level(cinode, oplock, epoch, purge_cache); 1323 1324 if (purge_cache) { 1325 *purge_cache = false; 1326 if (old_oplock == CIFS_CACHE_READ_FLG) { 1327 if (cinode->oplock == CIFS_CACHE_READ_FLG && 1328 (epoch - cinode->epoch > 0)) 1329 *purge_cache = true; 1330 else if (cinode->oplock == CIFS_CACHE_RH_FLG && 1331 (epoch - cinode->epoch > 1)) 1332 *purge_cache = true; 1333 else if (cinode->oplock == CIFS_CACHE_RHW_FLG && 1334 (epoch - cinode->epoch > 1)) 1335 *purge_cache = true; 1336 else if (cinode->oplock == 0 && 1337 (epoch - cinode->epoch > 0)) 1338 *purge_cache = true; 1339 } else if (old_oplock == CIFS_CACHE_RH_FLG) { 1340 if (cinode->oplock == CIFS_CACHE_RH_FLG && 1341 (epoch - cinode->epoch > 0)) 1342 *purge_cache = true; 1343 else if (cinode->oplock == CIFS_CACHE_RHW_FLG && 1344 (epoch - cinode->epoch > 1)) 1345 *purge_cache = true; 1346 } 1347 cinode->epoch = epoch; 1348 } 1349} 1350 1351static bool 1352smb2_is_read_op(__u32 oplock) 1353{ 1354 return oplock == SMB2_OPLOCK_LEVEL_II; 1355} 1356 1357static bool 1358smb21_is_read_op(__u32 oplock) 1359{ 1360 return (oplock & SMB2_LEASE_READ_CACHING_HE) && 1361 !(oplock & SMB2_LEASE_WRITE_CACHING_HE); 1362} 1363 1364static __le32 1365map_oplock_to_lease(u8 oplock) 1366{ 1367 if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) 1368 return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING; 1369 else if (oplock == SMB2_OPLOCK_LEVEL_II) 1370 return SMB2_LEASE_READ_CACHING; 1371 else if (oplock == SMB2_OPLOCK_LEVEL_BATCH) 1372 return SMB2_LEASE_HANDLE_CACHING | SMB2_LEASE_READ_CACHING | 1373 SMB2_LEASE_WRITE_CACHING; 1374 return 0; 1375} 1376 1377static char * 1378smb2_create_lease_buf(u8 *lease_key, u8 oplock) 1379{ 1380 struct create_lease *buf; 1381 1382 buf = kzalloc(sizeof(struct create_lease), GFP_KERNEL); 1383 if (!buf) 1384 return NULL; 1385 1386 buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key)); 1387 buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8))); 1388 buf->lcontext.LeaseState = map_oplock_to_lease(oplock); 1389 1390 buf->ccontext.DataOffset = cpu_to_le16(offsetof 1391 (struct create_lease, lcontext)); 1392 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context)); 1393 buf->ccontext.NameOffset = cpu_to_le16(offsetof 1394 (struct create_lease, Name)); 1395 buf->ccontext.NameLength = cpu_to_le16(4); 1396 /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */ 1397 buf->Name[0] = 'R'; 1398 buf->Name[1] = 'q'; 1399 buf->Name[2] = 'L'; 1400 buf->Name[3] = 's'; 1401 return (char *)buf; 1402} 1403 1404static char * 1405smb3_create_lease_buf(u8 *lease_key, u8 oplock) 1406{ 1407 struct create_lease_v2 *buf; 1408 1409 buf = kzalloc(sizeof(struct create_lease_v2), GFP_KERNEL); 1410 if (!buf) 1411 return NULL; 1412 1413 buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key)); 1414 buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8))); 1415 buf->lcontext.LeaseState = map_oplock_to_lease(oplock); 1416 1417 buf->ccontext.DataOffset = cpu_to_le16(offsetof 1418 (struct create_lease_v2, lcontext)); 1419 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context_v2)); 1420 buf->ccontext.NameOffset = cpu_to_le16(offsetof 1421 (struct create_lease_v2, Name)); 1422 buf->ccontext.NameLength = cpu_to_le16(4); 1423 /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */ 1424 buf->Name[0] = 'R'; 1425 buf->Name[1] = 'q'; 1426 buf->Name[2] = 'L'; 1427 buf->Name[3] = 's'; 1428 return (char *)buf; 1429} 1430 1431static __u8 1432smb2_parse_lease_buf(void *buf, unsigned int *epoch) 1433{ 1434 struct create_lease *lc = (struct create_lease *)buf; 1435 1436 *epoch = 0; /* not used */ 1437 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS) 1438 return SMB2_OPLOCK_LEVEL_NOCHANGE; 1439 return le32_to_cpu(lc->lcontext.LeaseState); 1440} 1441 1442static __u8 1443smb3_parse_lease_buf(void *buf, unsigned int *epoch) 1444{ 1445 struct create_lease_v2 *lc = (struct create_lease_v2 *)buf; 1446 1447 *epoch = le16_to_cpu(lc->lcontext.Epoch); 1448 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS) 1449 return SMB2_OPLOCK_LEVEL_NOCHANGE; 1450 return le32_to_cpu(lc->lcontext.LeaseState); 1451} 1452 1453static unsigned int 1454smb2_wp_retry_size(struct inode *inode) 1455{ 1456 return min_t(unsigned int, CIFS_SB(inode->i_sb)->wsize, 1457 SMB2_MAX_BUFFER_SIZE); 1458} 1459 1460static bool 1461smb2_dir_needs_close(struct cifsFileInfo *cfile) 1462{ 1463 return !cfile->invalidHandle; 1464} 1465 1466struct smb_version_operations smb20_operations = { 1467 .compare_fids = smb2_compare_fids, 1468 .setup_request = smb2_setup_request, 1469 .setup_async_request = smb2_setup_async_request, 1470 .check_receive = smb2_check_receive, 1471 .add_credits = smb2_add_credits, 1472 .set_credits = smb2_set_credits, 1473 .get_credits_field = smb2_get_credits_field, 1474 .get_credits = smb2_get_credits, 1475 .wait_mtu_credits = cifs_wait_mtu_credits, 1476 .get_next_mid = smb2_get_next_mid, 1477 .read_data_offset = smb2_read_data_offset, 1478 .read_data_length = smb2_read_data_length, 1479 .map_error = map_smb2_to_linux_error, 1480 .find_mid = smb2_find_mid, 1481 .check_message = smb2_check_message, 1482 .dump_detail = smb2_dump_detail, 1483 .clear_stats = smb2_clear_stats, 1484 .print_stats = smb2_print_stats, 1485 .is_oplock_break = smb2_is_valid_oplock_break, 1486 .downgrade_oplock = smb2_downgrade_oplock, 1487 .need_neg = smb2_need_neg, 1488 .negotiate = smb2_negotiate, 1489 .negotiate_wsize = smb2_negotiate_wsize, 1490 .negotiate_rsize = smb2_negotiate_rsize, 1491 .sess_setup = SMB2_sess_setup, 1492 .logoff = SMB2_logoff, 1493 .tree_connect = SMB2_tcon, 1494 .tree_disconnect = SMB2_tdis, 1495 .qfs_tcon = smb2_qfs_tcon, 1496 .is_path_accessible = smb2_is_path_accessible, 1497 .can_echo = smb2_can_echo, 1498 .echo = SMB2_echo, 1499 .query_path_info = smb2_query_path_info, 1500 .get_srv_inum = smb2_get_srv_inum, 1501 .query_file_info = smb2_query_file_info, 1502 .set_path_size = smb2_set_path_size, 1503 .set_file_size = smb2_set_file_size, 1504 .set_file_info = smb2_set_file_info, 1505 .set_compression = smb2_set_compression, 1506 .mkdir = smb2_mkdir, 1507 .mkdir_setinfo = smb2_mkdir_setinfo, 1508 .rmdir = smb2_rmdir, 1509 .unlink = smb2_unlink, 1510 .rename = smb2_rename_path, 1511 .create_hardlink = smb2_create_hardlink, 1512 .query_symlink = smb2_query_symlink, 1513 .open = smb2_open_file, 1514 .set_fid = smb2_set_fid, 1515 .close = smb2_close_file, 1516 .flush = smb2_flush_file, 1517 .async_readv = smb2_async_readv, 1518 .async_writev = smb2_async_writev, 1519 .sync_read = smb2_sync_read, 1520 .sync_write = smb2_sync_write, 1521 .query_dir_first = smb2_query_dir_first, 1522 .query_dir_next = smb2_query_dir_next, 1523 .close_dir = smb2_close_dir, 1524 .calc_smb_size = smb2_calc_size, 1525 .is_status_pending = smb2_is_status_pending, 1526 .oplock_response = smb2_oplock_response, 1527 .queryfs = smb2_queryfs, 1528 .mand_lock = smb2_mand_lock, 1529 .mand_unlock_range = smb2_unlock_range, 1530 .push_mand_locks = smb2_push_mandatory_locks, 1531 .get_lease_key = smb2_get_lease_key, 1532 .set_lease_key = smb2_set_lease_key, 1533 .new_lease_key = smb2_new_lease_key, 1534 .calc_signature = smb2_calc_signature, 1535 .is_read_op = smb2_is_read_op, 1536 .set_oplock_level = smb2_set_oplock_level, 1537 .create_lease_buf = smb2_create_lease_buf, 1538 .parse_lease_buf = smb2_parse_lease_buf, 1539 .clone_range = smb2_clone_range, 1540 .wp_retry_size = smb2_wp_retry_size, 1541 .dir_needs_close = smb2_dir_needs_close, 1542}; 1543 1544struct smb_version_operations smb21_operations = { 1545 .compare_fids = smb2_compare_fids, 1546 .setup_request = smb2_setup_request, 1547 .setup_async_request = smb2_setup_async_request, 1548 .check_receive = smb2_check_receive, 1549 .add_credits = smb2_add_credits, 1550 .set_credits = smb2_set_credits, 1551 .get_credits_field = smb2_get_credits_field, 1552 .get_credits = smb2_get_credits, 1553 .wait_mtu_credits = smb2_wait_mtu_credits, 1554 .get_next_mid = smb2_get_next_mid, 1555 .read_data_offset = smb2_read_data_offset, 1556 .read_data_length = smb2_read_data_length, 1557 .map_error = map_smb2_to_linux_error, 1558 .find_mid = smb2_find_mid, 1559 .check_message = smb2_check_message, 1560 .dump_detail = smb2_dump_detail, 1561 .clear_stats = smb2_clear_stats, 1562 .print_stats = smb2_print_stats, 1563 .is_oplock_break = smb2_is_valid_oplock_break, 1564 .downgrade_oplock = smb2_downgrade_oplock, 1565 .need_neg = smb2_need_neg, 1566 .negotiate = smb2_negotiate, 1567 .negotiate_wsize = smb2_negotiate_wsize, 1568 .negotiate_rsize = smb2_negotiate_rsize, 1569 .sess_setup = SMB2_sess_setup, 1570 .logoff = SMB2_logoff, 1571 .tree_connect = SMB2_tcon, 1572 .tree_disconnect = SMB2_tdis, 1573 .qfs_tcon = smb2_qfs_tcon, 1574 .is_path_accessible = smb2_is_path_accessible, 1575 .can_echo = smb2_can_echo, 1576 .echo = SMB2_echo, 1577 .query_path_info = smb2_query_path_info, 1578 .get_srv_inum = smb2_get_srv_inum, 1579 .query_file_info = smb2_query_file_info, 1580 .set_path_size = smb2_set_path_size, 1581 .set_file_size = smb2_set_file_size, 1582 .set_file_info = smb2_set_file_info, 1583 .set_compression = smb2_set_compression, 1584 .mkdir = smb2_mkdir, 1585 .mkdir_setinfo = smb2_mkdir_setinfo, 1586 .rmdir = smb2_rmdir, 1587 .unlink = smb2_unlink, 1588 .rename = smb2_rename_path, 1589 .create_hardlink = smb2_create_hardlink, 1590 .query_symlink = smb2_query_symlink, 1591 .query_mf_symlink = smb3_query_mf_symlink, 1592 .create_mf_symlink = smb3_create_mf_symlink, 1593 .open = smb2_open_file, 1594 .set_fid = smb2_set_fid, 1595 .close = smb2_close_file, 1596 .flush = smb2_flush_file, 1597 .async_readv = smb2_async_readv, 1598 .async_writev = smb2_async_writev, 1599 .sync_read = smb2_sync_read, 1600 .sync_write = smb2_sync_write, 1601 .query_dir_first = smb2_query_dir_first, 1602 .query_dir_next = smb2_query_dir_next, 1603 .close_dir = smb2_close_dir, 1604 .calc_smb_size = smb2_calc_size, 1605 .is_status_pending = smb2_is_status_pending, 1606 .oplock_response = smb2_oplock_response, 1607 .queryfs = smb2_queryfs, 1608 .mand_lock = smb2_mand_lock, 1609 .mand_unlock_range = smb2_unlock_range, 1610 .push_mand_locks = smb2_push_mandatory_locks, 1611 .get_lease_key = smb2_get_lease_key, 1612 .set_lease_key = smb2_set_lease_key, 1613 .new_lease_key = smb2_new_lease_key, 1614 .calc_signature = smb2_calc_signature, 1615 .is_read_op = smb21_is_read_op, 1616 .set_oplock_level = smb21_set_oplock_level, 1617 .create_lease_buf = smb2_create_lease_buf, 1618 .parse_lease_buf = smb2_parse_lease_buf, 1619 .clone_range = smb2_clone_range, 1620 .wp_retry_size = smb2_wp_retry_size, 1621 .dir_needs_close = smb2_dir_needs_close, 1622}; 1623 1624struct smb_version_operations smb30_operations = { 1625 .compare_fids = smb2_compare_fids, 1626 .setup_request = smb2_setup_request, 1627 .setup_async_request = smb2_setup_async_request, 1628 .check_receive = smb2_check_receive, 1629 .add_credits = smb2_add_credits, 1630 .set_credits = smb2_set_credits, 1631 .get_credits_field = smb2_get_credits_field, 1632 .get_credits = smb2_get_credits, 1633 .wait_mtu_credits = smb2_wait_mtu_credits, 1634 .get_next_mid = smb2_get_next_mid, 1635 .read_data_offset = smb2_read_data_offset, 1636 .read_data_length = smb2_read_data_length, 1637 .map_error = map_smb2_to_linux_error, 1638 .find_mid = smb2_find_mid, 1639 .check_message = smb2_check_message, 1640 .dump_detail = smb2_dump_detail, 1641 .clear_stats = smb2_clear_stats, 1642 .print_stats = smb2_print_stats, 1643 .dump_share_caps = smb2_dump_share_caps, 1644 .is_oplock_break = smb2_is_valid_oplock_break, 1645 .downgrade_oplock = smb2_downgrade_oplock, 1646 .need_neg = smb2_need_neg, 1647 .negotiate = smb2_negotiate, 1648 .negotiate_wsize = smb2_negotiate_wsize, 1649 .negotiate_rsize = smb2_negotiate_rsize, 1650 .sess_setup = SMB2_sess_setup, 1651 .logoff = SMB2_logoff, 1652 .tree_connect = SMB2_tcon, 1653 .tree_disconnect = SMB2_tdis, 1654 .qfs_tcon = smb3_qfs_tcon, 1655 .is_path_accessible = smb2_is_path_accessible, 1656 .can_echo = smb2_can_echo, 1657 .echo = SMB2_echo, 1658 .query_path_info = smb2_query_path_info, 1659 .get_srv_inum = smb2_get_srv_inum, 1660 .query_file_info = smb2_query_file_info, 1661 .set_path_size = smb2_set_path_size, 1662 .set_file_size = smb2_set_file_size, 1663 .set_file_info = smb2_set_file_info, 1664 .set_compression = smb2_set_compression, 1665 .mkdir = smb2_mkdir, 1666 .mkdir_setinfo = smb2_mkdir_setinfo, 1667 .rmdir = smb2_rmdir, 1668 .unlink = smb2_unlink, 1669 .rename = smb2_rename_path, 1670 .create_hardlink = smb2_create_hardlink, 1671 .query_symlink = smb2_query_symlink, 1672 .query_mf_symlink = smb3_query_mf_symlink, 1673 .create_mf_symlink = smb3_create_mf_symlink, 1674 .open = smb2_open_file, 1675 .set_fid = smb2_set_fid, 1676 .close = smb2_close_file, 1677 .flush = smb2_flush_file, 1678 .async_readv = smb2_async_readv, 1679 .async_writev = smb2_async_writev, 1680 .sync_read = smb2_sync_read, 1681 .sync_write = smb2_sync_write, 1682 .query_dir_first = smb2_query_dir_first, 1683 .query_dir_next = smb2_query_dir_next, 1684 .close_dir = smb2_close_dir, 1685 .calc_smb_size = smb2_calc_size, 1686 .is_status_pending = smb2_is_status_pending, 1687 .oplock_response = smb2_oplock_response, 1688 .queryfs = smb2_queryfs, 1689 .mand_lock = smb2_mand_lock, 1690 .mand_unlock_range = smb2_unlock_range, 1691 .push_mand_locks = smb2_push_mandatory_locks, 1692 .get_lease_key = smb2_get_lease_key, 1693 .set_lease_key = smb2_set_lease_key, 1694 .new_lease_key = smb2_new_lease_key, 1695 .generate_signingkey = generate_smb3signingkey, 1696 .calc_signature = smb3_calc_signature, 1697 .set_integrity = smb3_set_integrity, 1698 .is_read_op = smb21_is_read_op, 1699 .set_oplock_level = smb3_set_oplock_level, 1700 .create_lease_buf = smb3_create_lease_buf, 1701 .parse_lease_buf = smb3_parse_lease_buf, 1702 .clone_range = smb2_clone_range, 1703 .duplicate_extents = smb2_duplicate_extents, 1704 .validate_negotiate = smb3_validate_negotiate, 1705 .wp_retry_size = smb2_wp_retry_size, 1706 .dir_needs_close = smb2_dir_needs_close, 1707 .fallocate = smb3_fallocate, 1708}; 1709 1710#ifdef CONFIG_CIFS_SMB311 1711struct smb_version_operations smb311_operations = { 1712 .compare_fids = smb2_compare_fids, 1713 .setup_request = smb2_setup_request, 1714 .setup_async_request = smb2_setup_async_request, 1715 .check_receive = smb2_check_receive, 1716 .add_credits = smb2_add_credits, 1717 .set_credits = smb2_set_credits, 1718 .get_credits_field = smb2_get_credits_field, 1719 .get_credits = smb2_get_credits, 1720 .wait_mtu_credits = smb2_wait_mtu_credits, 1721 .get_next_mid = smb2_get_next_mid, 1722 .read_data_offset = smb2_read_data_offset, 1723 .read_data_length = smb2_read_data_length, 1724 .map_error = map_smb2_to_linux_error, 1725 .find_mid = smb2_find_mid, 1726 .check_message = smb2_check_message, 1727 .dump_detail = smb2_dump_detail, 1728 .clear_stats = smb2_clear_stats, 1729 .print_stats = smb2_print_stats, 1730 .dump_share_caps = smb2_dump_share_caps, 1731 .is_oplock_break = smb2_is_valid_oplock_break, 1732 .downgrade_oplock = smb2_downgrade_oplock, 1733 .need_neg = smb2_need_neg, 1734 .negotiate = smb2_negotiate, 1735 .negotiate_wsize = smb2_negotiate_wsize, 1736 .negotiate_rsize = smb2_negotiate_rsize, 1737 .sess_setup = SMB2_sess_setup, 1738 .logoff = SMB2_logoff, 1739 .tree_connect = SMB2_tcon, 1740 .tree_disconnect = SMB2_tdis, 1741 .qfs_tcon = smb3_qfs_tcon, 1742 .is_path_accessible = smb2_is_path_accessible, 1743 .can_echo = smb2_can_echo, 1744 .echo = SMB2_echo, 1745 .query_path_info = smb2_query_path_info, 1746 .get_srv_inum = smb2_get_srv_inum, 1747 .query_file_info = smb2_query_file_info, 1748 .set_path_size = smb2_set_path_size, 1749 .set_file_size = smb2_set_file_size, 1750 .set_file_info = smb2_set_file_info, 1751 .set_compression = smb2_set_compression, 1752 .mkdir = smb2_mkdir, 1753 .mkdir_setinfo = smb2_mkdir_setinfo, 1754 .rmdir = smb2_rmdir, 1755 .unlink = smb2_unlink, 1756 .rename = smb2_rename_path, 1757 .create_hardlink = smb2_create_hardlink, 1758 .query_symlink = smb2_query_symlink, 1759 .query_mf_symlink = smb3_query_mf_symlink, 1760 .create_mf_symlink = smb3_create_mf_symlink, 1761 .open = smb2_open_file, 1762 .set_fid = smb2_set_fid, 1763 .close = smb2_close_file, 1764 .flush = smb2_flush_file, 1765 .async_readv = smb2_async_readv, 1766 .async_writev = smb2_async_writev, 1767 .sync_read = smb2_sync_read, 1768 .sync_write = smb2_sync_write, 1769 .query_dir_first = smb2_query_dir_first, 1770 .query_dir_next = smb2_query_dir_next, 1771 .close_dir = smb2_close_dir, 1772 .calc_smb_size = smb2_calc_size, 1773 .is_status_pending = smb2_is_status_pending, 1774 .oplock_response = smb2_oplock_response, 1775 .queryfs = smb2_queryfs, 1776 .mand_lock = smb2_mand_lock, 1777 .mand_unlock_range = smb2_unlock_range, 1778 .push_mand_locks = smb2_push_mandatory_locks, 1779 .get_lease_key = smb2_get_lease_key, 1780 .set_lease_key = smb2_set_lease_key, 1781 .new_lease_key = smb2_new_lease_key, 1782 .generate_signingkey = generate_smb3signingkey, 1783 .calc_signature = smb3_calc_signature, 1784 .set_integrity = smb3_set_integrity, 1785 .is_read_op = smb21_is_read_op, 1786 .set_oplock_level = smb3_set_oplock_level, 1787 .create_lease_buf = smb3_create_lease_buf, 1788 .parse_lease_buf = smb3_parse_lease_buf, 1789 .clone_range = smb2_clone_range, 1790 .duplicate_extents = smb2_duplicate_extents, 1791/* .validate_negotiate = smb3_validate_negotiate, */ /* not used in 3.11 */ 1792 .wp_retry_size = smb2_wp_retry_size, 1793 .dir_needs_close = smb2_dir_needs_close, 1794 .fallocate = smb3_fallocate, 1795}; 1796#endif /* CIFS_SMB311 */ 1797 1798struct smb_version_values smb20_values = { 1799 .version_string = SMB20_VERSION_STRING, 1800 .protocol_id = SMB20_PROT_ID, 1801 .req_capabilities = 0, /* MBZ */ 1802 .large_lock_type = 0, 1803 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, 1804 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, 1805 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, 1806 .header_size = sizeof(struct smb2_hdr), 1807 .max_header_size = MAX_SMB2_HDR_SIZE, 1808 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, 1809 .lock_cmd = SMB2_LOCK, 1810 .cap_unix = 0, 1811 .cap_nt_find = SMB2_NT_FIND, 1812 .cap_large_files = SMB2_LARGE_FILES, 1813 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, 1814 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, 1815 .create_lease_size = sizeof(struct create_lease), 1816}; 1817 1818struct smb_version_values smb21_values = { 1819 .version_string = SMB21_VERSION_STRING, 1820 .protocol_id = SMB21_PROT_ID, 1821 .req_capabilities = 0, /* MBZ on negotiate req until SMB3 dialect */ 1822 .large_lock_type = 0, 1823 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, 1824 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, 1825 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, 1826 .header_size = sizeof(struct smb2_hdr), 1827 .max_header_size = MAX_SMB2_HDR_SIZE, 1828 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, 1829 .lock_cmd = SMB2_LOCK, 1830 .cap_unix = 0, 1831 .cap_nt_find = SMB2_NT_FIND, 1832 .cap_large_files = SMB2_LARGE_FILES, 1833 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, 1834 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, 1835 .create_lease_size = sizeof(struct create_lease), 1836}; 1837 1838struct smb_version_values smb30_values = { 1839 .version_string = SMB30_VERSION_STRING, 1840 .protocol_id = SMB30_PROT_ID, 1841 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES, 1842 .large_lock_type = 0, 1843 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, 1844 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, 1845 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, 1846 .header_size = sizeof(struct smb2_hdr), 1847 .max_header_size = MAX_SMB2_HDR_SIZE, 1848 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, 1849 .lock_cmd = SMB2_LOCK, 1850 .cap_unix = 0, 1851 .cap_nt_find = SMB2_NT_FIND, 1852 .cap_large_files = SMB2_LARGE_FILES, 1853 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, 1854 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, 1855 .create_lease_size = sizeof(struct create_lease_v2), 1856}; 1857 1858struct smb_version_values smb302_values = { 1859 .version_string = SMB302_VERSION_STRING, 1860 .protocol_id = SMB302_PROT_ID, 1861 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES, 1862 .large_lock_type = 0, 1863 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, 1864 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, 1865 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, 1866 .header_size = sizeof(struct smb2_hdr), 1867 .max_header_size = MAX_SMB2_HDR_SIZE, 1868 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, 1869 .lock_cmd = SMB2_LOCK, 1870 .cap_unix = 0, 1871 .cap_nt_find = SMB2_NT_FIND, 1872 .cap_large_files = SMB2_LARGE_FILES, 1873 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, 1874 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, 1875 .create_lease_size = sizeof(struct create_lease_v2), 1876}; 1877 1878#ifdef CONFIG_CIFS_SMB311 1879struct smb_version_values smb311_values = { 1880 .version_string = SMB311_VERSION_STRING, 1881 .protocol_id = SMB311_PROT_ID, 1882 .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU | SMB2_GLOBAL_CAP_PERSISTENT_HANDLES, 1883 .large_lock_type = 0, 1884 .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK, 1885 .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK, 1886 .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK, 1887 .header_size = sizeof(struct smb2_hdr), 1888 .max_header_size = MAX_SMB2_HDR_SIZE, 1889 .read_rsp_size = sizeof(struct smb2_read_rsp) - 1, 1890 .lock_cmd = SMB2_LOCK, 1891 .cap_unix = 0, 1892 .cap_nt_find = SMB2_NT_FIND, 1893 .cap_large_files = SMB2_LARGE_FILES, 1894 .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED, 1895 .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED, 1896 .create_lease_size = sizeof(struct create_lease_v2), 1897}; 1898#endif /* SMB311 */ 1899