Merge tag '5.2-rc-smb3-fixes' of git://git.samba.org/sfrench/cifs-2.6

+2

fs/cifs/cifs_debug.c

··· 380 380 atomic_read(&server->in_send), 381 381 atomic_read(&server->num_waiters)); 382 382 #endif 383 + /* dump session id helpful for use with network trace */ 384 + seq_printf(m, " SessionId: 0x%llx", ses->Suid); 383 385 if (ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) 384 386 seq_puts(m, " encrypted"); 385 387 if (ses->sign)

+9 -5

fs/cifs/cifsfs.c

··· 878 878 879 879 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence) 880 880 { 881 + struct cifsFileInfo *cfile = file->private_data; 882 + struct cifs_tcon *tcon; 883 + 881 884 /* 882 885 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate 883 886 * the cached file length ··· 911 908 rc = cifs_revalidate_file_attr(file); 912 909 if (rc < 0) 913 910 return (loff_t)rc; 911 + } 912 + if (cfile && cfile->tlink) { 913 + tcon = tlink_tcon(cfile->tlink); 914 + if (tcon->ses->server->ops->llseek) 915 + return tcon->ses->server->ops->llseek(file, tcon, 916 + offset, whence); 914 917 } 915 918 return generic_file_llseek(file, offset, whence); 916 919 } ··· 1078 1069 ssize_t rc; 1079 1070 1080 1071 cifs_dbg(FYI, "copychunk range\n"); 1081 - 1082 - if (src_inode == target_inode) { 1083 - rc = -EINVAL; 1084 - goto out; 1085 - } 1086 1072 1087 1073 if (!src_file->private_data || !dst_file->private_data) { 1088 1074 rc = -EBADF;

+2

fs/cifs/cifsglob.h

··· 497 497 /* version specific fiemap implementation */ 498 498 int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *, 499 499 struct fiemap_extent_info *, u64, u64); 500 + /* version specific llseek implementation */ 501 + loff_t (*llseek)(struct file *, struct cifs_tcon *, loff_t, int); 500 502 }; 501 503 502 504 struct smb_version_values {

+24 -17

fs/cifs/connect.c

··· 528 528 /* do not want to be sending data on a socket we are freeing */ 529 529 cifs_dbg(FYI, "%s: tearing down socket\n", __func__); 530 530 mutex_lock(&server->srv_mutex); 531 + if (server->ssocket) { 532 + cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", 533 + server->ssocket->state, server->ssocket->flags); 534 + kernel_sock_shutdown(server->ssocket, SHUT_WR); 535 + cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", 536 + server->ssocket->state, server->ssocket->flags); 537 + sock_release(server->ssocket); 538 + server->ssocket = NULL; 539 + } 540 + server->sequence_number = 0; 541 + server->session_estab = false; 542 + kfree(server->session_key.response); 543 + server->session_key.response = NULL; 544 + server->session_key.len = 0; 545 + server->lstrp = jiffies; 531 546 532 547 /* mark submitted MIDs for retry and issue callback */ 533 548 INIT_LIST_HEAD(&retry_list); ··· 555 540 list_move(&mid_entry->qhead, &retry_list); 556 541 } 557 542 spin_unlock(&GlobalMid_Lock); 543 + mutex_unlock(&server->srv_mutex); 558 544 559 545 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__); 560 546 list_for_each_safe(tmp, tmp2, &retry_list) { ··· 564 548 mid_entry->callback(mid_entry); 565 549 } 566 550 567 - if (server->ssocket) { 568 - cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", 569 - server->ssocket->state, server->ssocket->flags); 570 - kernel_sock_shutdown(server->ssocket, SHUT_WR); 571 - cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", 572 - server->ssocket->state, server->ssocket->flags); 573 - sock_release(server->ssocket); 574 - server->ssocket = NULL; 575 - } else if (cifs_rdma_enabled(server)) 551 + if (cifs_rdma_enabled(server)) { 552 + mutex_lock(&server->srv_mutex); 576 553 smbd_destroy(server); 577 - server->sequence_number = 0; 578 - server->session_estab = false; 579 - kfree(server->session_key.response); 580 - server->session_key.response = NULL; 581 - server->session_key.len = 0; 582 - server->lstrp = jiffies; 583 - 584 - mutex_unlock(&server->srv_mutex); 554 + mutex_unlock(&server->srv_mutex); 555 + } 585 556 586 557 do { 587 558 try_to_freeze(); ··· 2445 2442 match_port(struct TCP_Server_Info *server, struct sockaddr *addr) 2446 2443 { 2447 2444 __be16 port, *sport; 2445 + 2446 + /* SMBDirect manages its own ports, don't match it here */ 2447 + if (server->rdma) 2448 + return true; 2448 2449 2449 2450 switch (addr->sa_family) { 2450 2451 case AF_INET:

+111 -23

fs/cifs/smb2ops.c

··· 1 + // SPDX-License-Identifier: GPL-2.0 1 2 /* 2 3 * SMB2 version specific operations 3 4 * ··· 283 282 __u64 wire_mid = le64_to_cpu(shdr->MessageId); 284 283 285 284 if (shdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM) { 286 - cifs_dbg(VFS, "encrypted frame parsing not supported yet"); 285 + cifs_dbg(VFS, "Encrypted frame parsing not supported yet\n"); 287 286 return NULL; 288 287 } 289 288 ··· 325 324 smb2_negotiate(const unsigned int xid, struct cifs_ses *ses) 326 325 { 327 326 int rc; 327 + 328 328 ses->server->CurrentMid = 0; 329 329 rc = SMB2_negotiate(xid, ses); 330 330 /* BB we probably don't need to retry with modern servers */ ··· 791 789 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 792 790 else 793 791 close_shroot(&tcon->crfid); 794 - 795 - return; 796 792 } 797 793 798 794 static void ··· 818 818 SMB2_QFS_attr(xid, tcon, fid.persistent_fid, fid.volatile_fid, 819 819 FS_DEVICE_INFORMATION); 820 820 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 821 - return; 822 821 } 823 822 824 823 static int ··· 905 906 value = &src->ea_data[src->ea_name_length + 1]; 906 907 value_len = (size_t)le16_to_cpu(src->ea_value_length); 907 908 908 - if (name_len == 0) { 909 + if (name_len == 0) 909 910 break; 910 - } 911 911 912 912 if (src_size < 8 + name_len + 1 + value_len) { 913 913 cifs_dbg(FYI, "EA entry goes beyond length of list\n"); ··· 1159 1161 smb2_clear_stats(struct cifs_tcon *tcon) 1160 1162 { 1161 1163 int i; 1164 + 1162 1165 for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) { 1163 1166 atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0); 1164 1167 atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0); ··· 1528 1529 if (pcchunk == NULL) 1529 1530 return -ENOMEM; 1530 1531 1531 - cifs_dbg(FYI, "in smb2_copychunk_range - about to call request res key\n"); 1532 + cifs_dbg(FYI, "%s: about to call request res key\n", __func__); 1532 1533 /* Request a key from the server to identify the source of the copy */ 1533 1534 rc = SMB2_request_res_key(xid, tlink_tcon(srcfile->tlink), 1534 1535 srcfile->fid.persistent_fid, ··· 1648 1649 smb2_read_data_offset(char *buf) 1649 1650 { 1650 1651 struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf; 1652 + 1651 1653 return rsp->DataOffset; 1652 1654 } 1653 1655 ··· 1777 1777 dup_ext_buf.SourceFileOffset = cpu_to_le64(src_off); 1778 1778 dup_ext_buf.TargetFileOffset = cpu_to_le64(dest_off); 1779 1779 dup_ext_buf.ByteCount = cpu_to_le64(len); 1780 - cifs_dbg(FYI, "duplicate extents: src off %lld dst off %lld len %lld", 1780 + cifs_dbg(FYI, "Duplicate extents: src off %lld dst off %lld len %lld\n", 1781 1781 src_off, dest_off, len); 1782 1782 1783 1783 rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false); ··· 1794 1794 &ret_data_len); 1795 1795 1796 1796 if (ret_data_len > 0) 1797 - cifs_dbg(FYI, "non-zero response length in duplicate extents"); 1797 + cifs_dbg(FYI, "Non-zero response length in duplicate extents\n"); 1798 1798 1799 1799 duplicate_extents_out: 1800 1800 return rc; ··· 1983 1983 } 1984 1984 1985 1985 /* 1986 - * If we negotiate SMB2 protocol and get STATUS_PENDING - update 1987 - * the number of credits and return true. Otherwise - return false. 1988 - */ 1986 + * If we negotiate SMB2 protocol and get STATUS_PENDING - update 1987 + * the number of credits and return true. Otherwise - return false. 1988 + */ 1989 1989 static bool 1990 1990 smb2_is_status_pending(char *buf, struct TCP_Server_Info *server) 1991 1991 { ··· 2306 2306 struct get_dfs_referral_rsp *dfs_rsp = NULL; 2307 2307 u32 dfs_req_size = 0, dfs_rsp_size = 0; 2308 2308 2309 - cifs_dbg(FYI, "smb2_get_dfs_refer path <%s>\n", search_name); 2309 + cifs_dbg(FYI, "%s: path: %s\n", __func__, search_name); 2310 2310 2311 2311 /* 2312 2312 * Try to use the IPC tcon, otherwise just use any ··· 2360 2360 2361 2361 if (rc) { 2362 2362 if ((rc != -ENOENT) && (rc != -EOPNOTSUPP)) 2363 - cifs_dbg(VFS, "ioctl error in smb2_get_dfs_refer rc=%d\n", rc); 2363 + cifs_dbg(VFS, "ioctl error in %s rc=%d\n", __func__, rc); 2364 2364 goto out; 2365 2365 } 2366 2366 ··· 2369 2369 nls_codepage, remap, search_name, 2370 2370 true /* is_unicode */); 2371 2371 if (rc) { 2372 - cifs_dbg(VFS, "parse error in smb2_get_dfs_refer rc=%d\n", rc); 2372 + cifs_dbg(VFS, "parse error in %s rc=%d\n", __func__, rc); 2373 2373 goto out; 2374 2374 } 2375 2375 ··· 2745 2745 inode = d_inode(cfile->dentry); 2746 2746 cifsi = CIFS_I(inode); 2747 2747 2748 - trace_smb3_zero_enter(xid, cfile->fid.persistent_fid, tcon->tid, 2748 + trace_smb3_zero_enter(xid, cfile->fid.persistent_fid, tcon->tid, 2749 2749 ses->Suid, offset, len); 2750 2750 2751 2751 ··· 2759 2759 return rc; 2760 2760 } 2761 2761 2762 - cifs_dbg(FYI, "offset %lld len %lld", offset, len); 2762 + cifs_dbg(FYI, "Offset %lld len %lld\n", offset, len); 2763 2763 2764 2764 fsctl_buf.FileOffset = cpu_to_le64(offset); 2765 2765 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); ··· 2816 2816 return rc; 2817 2817 } 2818 2818 2819 - cifs_dbg(FYI, "offset %lld len %lld", offset, len); 2819 + cifs_dbg(FYI, "Offset %lld len %lld\n", offset, len); 2820 2820 2821 2821 fsctl_buf.FileOffset = cpu_to_le64(offset); 2822 2822 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); ··· 2920 2920 2921 2921 free_xid(xid); 2922 2922 return rc; 2923 + } 2924 + 2925 + static loff_t smb3_llseek(struct file *file, struct cifs_tcon *tcon, loff_t offset, int whence) 2926 + { 2927 + struct cifsFileInfo *wrcfile, *cfile = file->private_data; 2928 + struct cifsInodeInfo *cifsi; 2929 + struct inode *inode; 2930 + int rc = 0; 2931 + struct file_allocated_range_buffer in_data, *out_data = NULL; 2932 + u32 out_data_len; 2933 + unsigned int xid; 2934 + 2935 + if (whence != SEEK_HOLE && whence != SEEK_DATA) 2936 + return generic_file_llseek(file, offset, whence); 2937 + 2938 + inode = d_inode(cfile->dentry); 2939 + cifsi = CIFS_I(inode); 2940 + 2941 + if (offset < 0 || offset >= i_size_read(inode)) 2942 + return -ENXIO; 2943 + 2944 + xid = get_xid(); 2945 + /* 2946 + * We need to be sure that all dirty pages are written as they 2947 + * might fill holes on the server. 2948 + * Note that we also MUST flush any written pages since at least 2949 + * some servers (Windows2016) will not reflect recent writes in 2950 + * QUERY_ALLOCATED_RANGES until SMB2_flush is called. 2951 + */ 2952 + wrcfile = find_writable_file(cifsi, false); 2953 + if (wrcfile) { 2954 + filemap_write_and_wait(inode->i_mapping); 2955 + smb2_flush_file(xid, tcon, &wrcfile->fid); 2956 + cifsFileInfo_put(wrcfile); 2957 + } 2958 + 2959 + if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)) { 2960 + if (whence == SEEK_HOLE) 2961 + offset = i_size_read(inode); 2962 + goto lseek_exit; 2963 + } 2964 + 2965 + in_data.file_offset = cpu_to_le64(offset); 2966 + in_data.length = cpu_to_le64(i_size_read(inode)); 2967 + 2968 + rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 2969 + cfile->fid.volatile_fid, 2970 + FSCTL_QUERY_ALLOCATED_RANGES, true, 2971 + (char *)&in_data, sizeof(in_data), 2972 + sizeof(struct file_allocated_range_buffer), 2973 + (char **)&out_data, &out_data_len); 2974 + if (rc == -E2BIG) 2975 + rc = 0; 2976 + if (rc) 2977 + goto lseek_exit; 2978 + 2979 + if (whence == SEEK_HOLE && out_data_len == 0) 2980 + goto lseek_exit; 2981 + 2982 + if (whence == SEEK_DATA && out_data_len == 0) { 2983 + rc = -ENXIO; 2984 + goto lseek_exit; 2985 + } 2986 + 2987 + if (out_data_len < sizeof(struct file_allocated_range_buffer)) { 2988 + rc = -EINVAL; 2989 + goto lseek_exit; 2990 + } 2991 + if (whence == SEEK_DATA) { 2992 + offset = le64_to_cpu(out_data->file_offset); 2993 + goto lseek_exit; 2994 + } 2995 + if (offset < le64_to_cpu(out_data->file_offset)) 2996 + goto lseek_exit; 2997 + 2998 + offset = le64_to_cpu(out_data->file_offset) + le64_to_cpu(out_data->length); 2999 + 3000 + lseek_exit: 3001 + free_xid(xid); 3002 + kfree(out_data); 3003 + if (!rc) 3004 + return vfs_setpos(file, offset, inode->i_sb->s_maxbytes); 3005 + else 3006 + return rc; 2923 3007 } 2924 3008 2925 3009 static int smb3_fiemap(struct cifs_tcon *tcon, ··· 3468 3384 3469 3385 req = aead_request_alloc(tfm, GFP_KERNEL); 3470 3386 if (!req) { 3471 - cifs_dbg(VFS, "%s: Failed to alloc aead request", __func__); 3387 + cifs_dbg(VFS, "%s: Failed to alloc aead request\n", __func__); 3472 3388 return -ENOMEM; 3473 3389 } 3474 3390 ··· 3479 3395 3480 3396 sg = init_sg(num_rqst, rqst, sign); 3481 3397 if (!sg) { 3482 - cifs_dbg(VFS, "%s: Failed to init sg", __func__); 3398 + cifs_dbg(VFS, "%s: Failed to init sg\n", __func__); 3483 3399 rc = -ENOMEM; 3484 3400 goto free_req; 3485 3401 } ··· 3487 3403 iv_len = crypto_aead_ivsize(tfm); 3488 3404 iv = kzalloc(iv_len, GFP_KERNEL); 3489 3405 if (!iv) { 3490 - cifs_dbg(VFS, "%s: Failed to alloc IV", __func__); 3406 + cifs_dbg(VFS, "%s: Failed to alloc iv\n", __func__); 3491 3407 rc = -ENOMEM; 3492 3408 goto free_sg; 3493 3409 } ··· 3595 3511 fill_transform_hdr(tr_hdr, orig_len, old_rq); 3596 3512 3597 3513 rc = crypt_message(server, num_rqst, new_rq, 1); 3598 - cifs_dbg(FYI, "encrypt message returned %d", rc); 3514 + cifs_dbg(FYI, "Encrypt message returned %d\n", rc); 3599 3515 if (rc) 3600 3516 goto err_free; 3601 3517 ··· 3636 3552 rqst.rq_tailsz = (page_data_size % PAGE_SIZE) ? : PAGE_SIZE; 3637 3553 3638 3554 rc = crypt_message(server, 1, &rqst, 0); 3639 - cifs_dbg(FYI, "decrypt message returned %d\n", rc); 3555 + cifs_dbg(FYI, "Decrypt message returned %d\n", rc); 3640 3556 3641 3557 if (rc) 3642 3558 return rc; ··· 4250 4166 .ioctl_query_info = smb2_ioctl_query_info, 4251 4167 .make_node = smb2_make_node, 4252 4168 .fiemap = smb3_fiemap, 4169 + .llseek = smb3_llseek, 4253 4170 }; 4254 4171 4255 4172 struct smb_version_operations smb21_operations = { ··· 4351 4266 .ioctl_query_info = smb2_ioctl_query_info, 4352 4267 .make_node = smb2_make_node, 4353 4268 .fiemap = smb3_fiemap, 4269 + .llseek = smb3_llseek, 4354 4270 }; 4355 4271 4356 4272 struct smb_version_operations smb30_operations = { ··· 4461 4375 .ioctl_query_info = smb2_ioctl_query_info, 4462 4376 .make_node = smb2_make_node, 4463 4377 .fiemap = smb3_fiemap, 4378 + .llseek = smb3_llseek, 4464 4379 }; 4465 4380 4466 4381 struct smb_version_operations smb311_operations = { ··· 4572 4485 .ioctl_query_info = smb2_ioctl_query_info, 4573 4486 .make_node = smb2_make_node, 4574 4487 .fiemap = smb3_fiemap, 4488 + .llseek = smb3_llseek, 4575 4489 }; 4576 4490 4577 4491 struct smb_version_values smb20_values = {

+19 -2

fs/cifs/smb2pdu.c

··· 2538 2538 struct kvec *iov = rqst->rq_iov; 2539 2539 unsigned int total_len; 2540 2540 int rc; 2541 + char *in_data_buf; 2541 2542 2542 2543 rc = smb2_plain_req_init(SMB2_IOCTL, tcon, (void **) &req, &total_len); 2543 2544 if (rc) 2544 2545 return rc; 2546 + 2547 + if (indatalen) { 2548 + /* 2549 + * indatalen is usually small at a couple of bytes max, so 2550 + * just allocate through generic pool 2551 + */ 2552 + in_data_buf = kmalloc(indatalen, GFP_NOFS); 2553 + if (!in_data_buf) { 2554 + cifs_small_buf_release(req); 2555 + return -ENOMEM; 2556 + } 2557 + memcpy(in_data_buf, in_data, indatalen); 2558 + } 2545 2559 2546 2560 req->CtlCode = cpu_to_le32(opcode); 2547 2561 req->PersistentFileId = persistent_fid; ··· 2577 2563 cpu_to_le32(offsetof(struct smb2_ioctl_req, Buffer)); 2578 2564 rqst->rq_nvec = 2; 2579 2565 iov[0].iov_len = total_len - 1; 2580 - iov[1].iov_base = in_data; 2566 + iov[1].iov_base = in_data_buf; 2581 2567 iov[1].iov_len = indatalen; 2582 2568 } else { 2583 2569 rqst->rq_nvec = 1; ··· 2619 2605 void 2620 2606 SMB2_ioctl_free(struct smb_rqst *rqst) 2621 2607 { 2622 - if (rqst && rqst->rq_iov) 2608 + if (rqst && rqst->rq_iov) { 2623 2609 cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */ 2610 + if (rqst->rq_iov[1].iov_len) 2611 + kfree(rqst->rq_iov[1].iov_base); 2612 + } 2624 2613 } 2625 2614 2626 2615

+5 -3

fs/cifs/smbdirect.c

··· 903 903 request->sge[0].addr = ib_dma_map_single(info->id->device, 904 904 (void *)packet, 905 905 header_length, 906 - DMA_BIDIRECTIONAL); 906 + DMA_TO_DEVICE); 907 907 if (ib_dma_mapping_error(info->id->device, request->sge[0].addr)) { 908 908 mempool_free(request, info->request_mempool); 909 909 rc = -EIO; ··· 1005 1005 for_each_sg(sgl, sg, num_sgs, i) { 1006 1006 request->sge[i+1].addr = 1007 1007 ib_dma_map_page(info->id->device, sg_page(sg), 1008 - sg->offset, sg->length, DMA_BIDIRECTIONAL); 1008 + sg->offset, sg->length, DMA_TO_DEVICE); 1009 1009 if (ib_dma_mapping_error( 1010 1010 info->id->device, request->sge[i+1].addr)) { 1011 1011 rc = -EIO; ··· 2110 2110 goto done; 2111 2111 } 2112 2112 2113 - rqst_idx = 0; 2113 + log_write(INFO, "num_rqst=%d total length=%u\n", 2114 + num_rqst, remaining_data_length); 2114 2115 2116 + rqst_idx = 0; 2115 2117 next_rqst: 2116 2118 rqst = &rqst_array[rqst_idx]; 2117 2119 iov = rqst->rq_iov;

+1 -1

fs/cifs/transport.c

··· 33 33 #include <linux/uaccess.h> 34 34 #include <asm/processor.h> 35 35 #include <linux/mempool.h> 36 - #include <linux/signal.h> 36 + #include <linux/sched/signal.h> 37 37 #include "cifspdu.h" 38 38 #include "cifsglob.h" 39 39 #include "cifsproto.h"

Configure Feed

Configure Feed