+2 -1

fs/cifs/cifsglob.h

reviewed

··· 423 423 void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int, 424 424 bool *); 425 425 /* create lease context buffer for CREATE request */ 426 426 - char * (*create_lease_buf)(u8 *, u8); 426 426 + char * (*create_lease_buf)(u8 *lease_key, u8 oplock); 427 427 /* parse lease context buffer and return oplock/epoch info */ 428 428 __u8 (*parse_lease_buf)(void *buf, unsigned int *epoch, char *lkey); 429 429 ssize_t (*copychunk_range)(const unsigned int, ··· 1416 1416 /* one of these for every pending CIFS request to the server */ 1417 1417 struct mid_q_entry { 1418 1418 struct list_head qhead; /* mids waiting on reply from this server */ 1419 1419 + struct kref refcount; 1419 1420 struct TCP_Server_Info *server; /* server corresponding to this mid */ 1420 1421 __u64 mid; /* multiplex id */ 1421 1422 __u32 pid; /* process id */

+1

fs/cifs/cifsproto.h

reviewed

··· 82 82 struct TCP_Server_Info *server); 83 83 extern void DeleteMidQEntry(struct mid_q_entry *midEntry); 84 84 extern void cifs_delete_mid(struct mid_q_entry *mid); 85 85 + extern void cifs_mid_q_entry_release(struct mid_q_entry *midEntry); 85 86 extern void cifs_wake_up_task(struct mid_q_entry *mid); 86 87 extern int cifs_handle_standard(struct TCP_Server_Info *server, 87 88 struct mid_q_entry *mid);

+8 -2

fs/cifs/cifssmb.c

reviewed

··· 157 157 * greater than cifs socket timeout which is 7 seconds 158 158 */ 159 159 while (server->tcpStatus == CifsNeedReconnect) { 160 160 - wait_event_interruptible_timeout(server->response_q, 161 161 - (server->tcpStatus != CifsNeedReconnect), 10 * HZ); 160 160 + rc = wait_event_interruptible_timeout(server->response_q, 161 161 + (server->tcpStatus != CifsNeedReconnect), 162 162 + 10 * HZ); 163 163 + if (rc < 0) { 164 164 + cifs_dbg(FYI, "%s: aborting reconnect due to a received" 165 165 + " signal by the process\n", __func__); 166 166 + return -ERESTARTSYS; 167 167 + } 162 168 163 169 /* are we still trying to reconnect? */ 164 170 if (server->tcpStatus != CifsNeedReconnect)

+7 -1

fs/cifs/connect.c

reviewed

··· 924 924 server->pdu_size = next_offset; 925 925 } 926 926 927 927 + mid_entry = NULL; 927 928 if (server->ops->is_transform_hdr && 928 929 server->ops->receive_transform && 929 930 server->ops->is_transform_hdr(buf)) { ··· 939 938 length = mid_entry->receive(server, mid_entry); 940 939 } 941 940 942 942 - if (length < 0) 941 941 + if (length < 0) { 942 942 + if (mid_entry) 943 943 + cifs_mid_q_entry_release(mid_entry); 943 944 continue; 945 945 + } 944 946 945 947 if (server->large_buf) 946 948 buf = server->bigbuf; ··· 960 956 961 957 if (!mid_entry->multiRsp || mid_entry->multiEnd) 962 958 mid_entry->callback(mid_entry); 959 959 + 960 960 + cifs_mid_q_entry_release(mid_entry); 963 961 } else if (server->ops->is_oplock_break && 964 962 server->ops->is_oplock_break(buf, server)) { 965 963 cifs_dbg(FYI, "Received oplock break\n");

+1

fs/cifs/smb1ops.c

reviewed

··· 107 107 if (compare_mid(mid->mid, buf) && 108 108 mid->mid_state == MID_REQUEST_SUBMITTED && 109 109 le16_to_cpu(mid->command) == buf->Command) { 110 110 + kref_get(&mid->refcount); 110 111 spin_unlock(&GlobalMid_Lock); 111 112 return mid; 112 113 }

+4 -7

fs/cifs/smb2file.c

reviewed

··· 41 41 int rc; 42 42 __le16 *smb2_path; 43 43 struct smb2_file_all_info *smb2_data = NULL; 44 44 - __u8 smb2_oplock[17]; 44 44 + __u8 smb2_oplock; 45 45 struct cifs_fid *fid = oparms->fid; 46 46 struct network_resiliency_req nr_ioctl_req; 47 47 ··· 59 59 } 60 60 61 61 oparms->desired_access |= FILE_READ_ATTRIBUTES; 62 62 - *smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH; 62 62 + smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH; 63 63 64 64 - if (oparms->tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING) 65 65 - memcpy(smb2_oplock + 1, fid->lease_key, SMB2_LEASE_KEY_SIZE); 66 66 - 67 67 - rc = SMB2_open(xid, oparms, smb2_path, smb2_oplock, smb2_data, NULL, 64 64 + rc = SMB2_open(xid, oparms, smb2_path, &smb2_oplock, smb2_data, NULL, 68 65 NULL); 69 66 if (rc) 70 67 goto out; ··· 98 101 move_smb2_info_to_cifs(buf, smb2_data); 99 102 } 100 103 101 101 - *oplock = *smb2_oplock; 104 104 + *oplock = smb2_oplock; 102 105 out: 103 106 kfree(smb2_data); 104 107 kfree(smb2_path);

+7 -7

fs/cifs/smb2ops.c

reviewed

··· 203 203 if ((mid->mid == wire_mid) && 204 204 (mid->mid_state == MID_REQUEST_SUBMITTED) && 205 205 (mid->command == shdr->Command)) { 206 206 + kref_get(&mid->refcount); 206 207 spin_unlock(&GlobalMid_Lock); 207 208 return mid; 208 209 } ··· 856 855 857 856 rc = SMB2_set_ea(xid, tcon, fid.persistent_fid, fid.volatile_fid, ea, 858 857 len); 858 858 + kfree(ea); 859 859 + 859 860 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 860 861 861 862 return rc; ··· 2222 2219 if (!buf) 2223 2220 return NULL; 2224 2221 2225 2225 - buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key)); 2226 2226 - buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8))); 2222 2222 + memcpy(&buf->lcontext.LeaseKey, lease_key, SMB2_LEASE_KEY_SIZE); 2227 2223 buf->lcontext.LeaseState = map_oplock_to_lease(oplock); 2228 2224 2229 2225 buf->ccontext.DataOffset = cpu_to_le16(offsetof ··· 2248 2246 if (!buf) 2249 2247 return NULL; 2250 2248 2251 2251 - buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key)); 2252 2252 - buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8))); 2249 2249 + memcpy(&buf->lcontext.LeaseKey, lease_key, SMB2_LEASE_KEY_SIZE); 2253 2250 buf->lcontext.LeaseState = map_oplock_to_lease(oplock); 2254 2251 2255 2252 buf->ccontext.DataOffset = cpu_to_le16(offsetof ··· 2285 2284 if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS) 2286 2285 return SMB2_OPLOCK_LEVEL_NOCHANGE; 2287 2286 if (lease_key) 2288 2288 - memcpy(lease_key, &lc->lcontext.LeaseKeyLow, 2289 2289 - SMB2_LEASE_KEY_SIZE); 2287 2287 + memcpy(lease_key, &lc->lcontext.LeaseKey, SMB2_LEASE_KEY_SIZE); 2290 2288 return le32_to_cpu(lc->lcontext.LeaseState); 2291 2289 } 2292 2290 ··· 2521 2521 if (!tr_hdr) 2522 2522 goto err_free_iov; 2523 2523 2524 2524 - orig_len = smb2_rqst_len(old_rq, false); 2524 2524 + orig_len = smb_rqst_len(server, old_rq); 2525 2525 2526 2526 /* fill the 2nd iov with a transform header */ 2527 2527 fill_transform_hdr(tr_hdr, orig_len, old_rq);

+21 -11

fs/cifs/smb2pdu.c

reviewed

··· 155 155 static int 156 156 smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon) 157 157 { 158 158 - int rc = 0; 158 158 + int rc; 159 159 struct nls_table *nls_codepage; 160 160 struct cifs_ses *ses; 161 161 struct TCP_Server_Info *server; ··· 166 166 * for those three - in the calling routine. 167 167 */ 168 168 if (tcon == NULL) 169 169 - return rc; 169 169 + return 0; 170 170 171 171 if (smb2_command == SMB2_TREE_CONNECT) 172 172 - return rc; 172 172 + return 0; 173 173 174 174 if (tcon->tidStatus == CifsExiting) { 175 175 /* ··· 212 212 return -EAGAIN; 213 213 } 214 214 215 215 - wait_event_interruptible_timeout(server->response_q, 216 216 - (server->tcpStatus != CifsNeedReconnect), 10 * HZ); 215 215 + rc = wait_event_interruptible_timeout(server->response_q, 216 216 + (server->tcpStatus != CifsNeedReconnect), 217 217 + 10 * HZ); 218 218 + if (rc < 0) { 219 219 + cifs_dbg(FYI, "%s: aborting reconnect due to a received" 220 220 + " signal by the process\n", __func__); 221 221 + return -ERESTARTSYS; 222 222 + } 217 223 218 224 /* are we still trying to reconnect? */ 219 225 if (server->tcpStatus != CifsNeedReconnect) ··· 237 231 } 238 232 239 233 if (!tcon->ses->need_reconnect && !tcon->need_reconnect) 240 240 - return rc; 234 234 + return 0; 241 235 242 236 nls_codepage = load_nls_default(); 243 237 ··· 346 340 return rc; 347 341 348 342 /* BB eventually switch this to SMB2 specific small buf size */ 349 349 - *request_buf = cifs_small_buf_get(); 343 343 + if (smb2_command == SMB2_SET_INFO) 344 344 + *request_buf = cifs_buf_get(); 345 345 + else 346 346 + *request_buf = cifs_small_buf_get(); 350 347 if (*request_buf == NULL) { 351 348 /* BB should we add a retry in here if not a writepage? */ 352 349 return -ENOMEM; ··· 1716 1707 1717 1708 static int 1718 1709 add_lease_context(struct TCP_Server_Info *server, struct kvec *iov, 1719 1719 - unsigned int *num_iovec, __u8 *oplock) 1710 1710 + unsigned int *num_iovec, u8 *lease_key, __u8 *oplock) 1720 1711 { 1721 1712 struct smb2_create_req *req = iov[0].iov_base; 1722 1713 unsigned int num = *num_iovec; 1723 1714 1724 1724 - iov[num].iov_base = server->ops->create_lease_buf(oplock+1, *oplock); 1715 1715 + iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock); 1725 1716 if (iov[num].iov_base == NULL) 1726 1717 return -ENOMEM; 1727 1718 iov[num].iov_len = server->vals->create_lease_size; ··· 2181 2172 *oplock == SMB2_OPLOCK_LEVEL_NONE) 2182 2173 req->RequestedOplockLevel = *oplock; 2183 2174 else { 2184 2184 - rc = add_lease_context(server, iov, &n_iov, oplock); 2175 2175 + rc = add_lease_context(server, iov, &n_iov, 2176 2176 + oparms->fid->lease_key, oplock); 2185 2177 if (rc) { 2186 2178 cifs_small_buf_release(req); 2187 2179 kfree(copy_path); ··· 3730 3720 3731 3721 rc = cifs_send_recv(xid, ses, &rqst, &resp_buftype, flags, 3732 3722 &rsp_iov); 3733 3733 - cifs_small_buf_release(req); 3723 3723 + cifs_buf_release(req); 3734 3724 rsp = (struct smb2_set_info_rsp *)rsp_iov.iov_base; 3735 3725 3736 3726 if (rc != 0) {

+2 -4

fs/cifs/smb2pdu.h

reviewed

··· 678 678 #define SMB2_LEASE_KEY_SIZE 16 679 679 680 680 struct lease_context { 681 681 - __le64 LeaseKeyLow; 682 682 - __le64 LeaseKeyHigh; 681 681 + u8 LeaseKey[SMB2_LEASE_KEY_SIZE]; 683 682 __le32 LeaseState; 684 683 __le32 LeaseFlags; 685 684 __le64 LeaseDuration; 686 685 } __packed; 687 686 688 687 struct lease_context_v2 { 689 689 - __le64 LeaseKeyLow; 690 690 - __le64 LeaseKeyHigh; 688 688 + u8 LeaseKey[SMB2_LEASE_KEY_SIZE]; 691 689 __le32 LeaseState; 692 690 __le32 LeaseFlags; 693 691 __le64 LeaseDuration;

+2 -2

fs/cifs/smb2proto.h

reviewed

··· 113 113 extern int smb2_push_mandatory_locks(struct cifsFileInfo *cfile); 114 114 extern void smb2_reconnect_server(struct work_struct *work); 115 115 extern int smb3_crypto_aead_allocate(struct TCP_Server_Info *server); 116 116 - extern unsigned long 117 117 - smb2_rqst_len(struct smb_rqst *rqst, bool skip_rfc1002_marker); 116 116 + extern unsigned long smb_rqst_len(struct TCP_Server_Info *server, 117 117 + struct smb_rqst *rqst); 118 118 119 119 /* 120 120 * SMB2 Worker functions - most of protocol specific implementation details

+50 -10

fs/cifs/smb2transport.c

reviewed

··· 173 173 struct kvec *iov = rqst->rq_iov; 174 174 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)iov[0].iov_base; 175 175 struct cifs_ses *ses; 176 176 + struct shash_desc *shash = &server->secmech.sdeschmacsha256->shash; 177 177 + struct smb_rqst drqst; 176 178 177 179 ses = smb2_find_smb_ses(server, shdr->SessionId); 178 180 if (!ses) { ··· 192 190 } 193 191 194 192 rc = crypto_shash_setkey(server->secmech.hmacsha256, 195 195 - ses->auth_key.response, SMB2_NTLMV2_SESSKEY_SIZE); 193 193 + ses->auth_key.response, SMB2_NTLMV2_SESSKEY_SIZE); 196 194 if (rc) { 197 195 cifs_dbg(VFS, "%s: Could not update with response\n", __func__); 198 196 return rc; 199 197 } 200 198 201 201 - rc = crypto_shash_init(&server->secmech.sdeschmacsha256->shash); 199 199 + rc = crypto_shash_init(shash); 202 200 if (rc) { 203 201 cifs_dbg(VFS, "%s: Could not init sha256", __func__); 204 202 return rc; 205 203 } 206 204 207 207 - rc = __cifs_calc_signature(rqst, server, sigptr, 208 208 - &server->secmech.sdeschmacsha256->shash); 205 205 + /* 206 206 + * For SMB2+, __cifs_calc_signature() expects to sign only the actual 207 207 + * data, that is, iov[0] should not contain a rfc1002 length. 208 208 + * 209 209 + * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to 210 210 + * __cifs_calc_signature(). 211 211 + */ 212 212 + drqst = *rqst; 213 213 + if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) { 214 214 + rc = crypto_shash_update(shash, iov[0].iov_base, 215 215 + iov[0].iov_len); 216 216 + if (rc) { 217 217 + cifs_dbg(VFS, "%s: Could not update with payload\n", 218 218 + __func__); 219 219 + return rc; 220 220 + } 221 221 + drqst.rq_iov++; 222 222 + drqst.rq_nvec--; 223 223 + } 209 224 225 225 + rc = __cifs_calc_signature(&drqst, server, sigptr, shash); 210 226 if (!rc) 211 227 memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE); 212 228 ··· 428 408 int 429 409 smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server) 430 410 { 431 431 - int rc = 0; 411 411 + int rc; 432 412 unsigned char smb3_signature[SMB2_CMACAES_SIZE]; 433 413 unsigned char *sigptr = smb3_signature; 434 414 struct kvec *iov = rqst->rq_iov; 435 415 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)iov[0].iov_base; 436 416 struct cifs_ses *ses; 417 417 + struct shash_desc *shash = &server->secmech.sdesccmacaes->shash; 418 418 + struct smb_rqst drqst; 437 419 438 420 ses = smb2_find_smb_ses(server, shdr->SessionId); 439 421 if (!ses) { ··· 447 425 memset(shdr->Signature, 0x0, SMB2_SIGNATURE_SIZE); 448 426 449 427 rc = crypto_shash_setkey(server->secmech.cmacaes, 450 450 - ses->smb3signingkey, SMB2_CMACAES_SIZE); 451 451 - 428 428 + ses->smb3signingkey, SMB2_CMACAES_SIZE); 452 429 if (rc) { 453 430 cifs_dbg(VFS, "%s: Could not set key for cmac aes\n", __func__); 454 431 return rc; ··· 458 437 * so unlike smb2 case we do not have to check here if secmech are 459 438 * initialized 460 439 */ 461 461 - rc = crypto_shash_init(&server->secmech.sdesccmacaes->shash); 440 440 + rc = crypto_shash_init(shash); 462 441 if (rc) { 463 442 cifs_dbg(VFS, "%s: Could not init cmac aes\n", __func__); 464 443 return rc; 465 444 } 466 445 467 467 - rc = __cifs_calc_signature(rqst, server, sigptr, 468 468 - &server->secmech.sdesccmacaes->shash); 446 446 + /* 447 447 + * For SMB2+, __cifs_calc_signature() expects to sign only the actual 448 448 + * data, that is, iov[0] should not contain a rfc1002 length. 449 449 + * 450 450 + * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to 451 451 + * __cifs_calc_signature(). 452 452 + */ 453 453 + drqst = *rqst; 454 454 + if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) { 455 455 + rc = crypto_shash_update(shash, iov[0].iov_base, 456 456 + iov[0].iov_len); 457 457 + if (rc) { 458 458 + cifs_dbg(VFS, "%s: Could not update with payload\n", 459 459 + __func__); 460 460 + return rc; 461 461 + } 462 462 + drqst.rq_iov++; 463 463 + drqst.rq_nvec--; 464 464 + } 469 465 466 466 + rc = __cifs_calc_signature(&drqst, server, sigptr, shash); 470 467 if (!rc) 471 468 memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE); 472 469 ··· 587 548 588 549 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS); 589 550 memset(temp, 0, sizeof(struct mid_q_entry)); 551 551 + kref_init(&temp->refcount); 590 552 temp->mid = le64_to_cpu(shdr->MessageId); 591 553 temp->pid = current->pid; 592 554 temp->command = shdr->Command; /* Always LE */

+3 -2

fs/cifs/smbdirect.c

reviewed

··· 2083 2083 * rqst: the data to write 2084 2084 * return value: 0 if successfully write, otherwise error code 2085 2085 */ 2086 2086 - int smbd_send(struct smbd_connection *info, struct smb_rqst *rqst) 2086 2086 + int smbd_send(struct TCP_Server_Info *server, struct smb_rqst *rqst) 2087 2087 { 2088 2088 + struct smbd_connection *info = server->smbd_conn; 2088 2089 struct kvec vec; 2089 2090 int nvecs; 2090 2091 int size; ··· 2119 2118 * rq_tailsz to PAGE_SIZE when the buffer has multiple pages and 2120 2119 * ends at page boundary 2121 2120 */ 2122 2122 - buflen = smb2_rqst_len(rqst, true); 2121 2121 + buflen = smb_rqst_len(server, rqst); 2123 2122 2124 2123 if (buflen + sizeof(struct smbd_data_transfer) > 2125 2124 info->max_fragmented_send_size) {

+2 -2

fs/cifs/smbdirect.h

reviewed

··· 292 292 293 293 /* Interface for carrying upper layer I/O through send/recv */ 294 294 int smbd_recv(struct smbd_connection *info, struct msghdr *msg); 295 295 - int smbd_send(struct smbd_connection *info, struct smb_rqst *rqst); 295 295 + int smbd_send(struct TCP_Server_Info *server, struct smb_rqst *rqst); 296 296 297 297 enum mr_state { 298 298 MR_READY, ··· 332 332 static inline int smbd_reconnect(struct TCP_Server_Info *server) {return -1; } 333 333 static inline void smbd_destroy(struct smbd_connection *info) {} 334 334 static inline int smbd_recv(struct smbd_connection *info, struct msghdr *msg) {return -1; } 335 335 - static inline int smbd_send(struct smbd_connection *info, struct smb_rqst *rqst) {return -1; } 335 335 + static inline int smbd_send(struct TCP_Server_Info *server, struct smb_rqst *rqst) {return -1; } 336 336 #endif 337 337 338 338 #endif

+22 -5

fs/cifs/transport.c

reviewed

··· 61 61 62 62 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS); 63 63 memset(temp, 0, sizeof(struct mid_q_entry)); 64 64 + kref_init(&temp->refcount); 64 65 temp->mid = get_mid(smb_buffer); 65 66 temp->pid = current->pid; 66 67 temp->command = cpu_to_le16(smb_buffer->Command); ··· 81 80 atomic_inc(&midCount); 82 81 temp->mid_state = MID_REQUEST_ALLOCATED; 83 82 return temp; 83 83 + } 84 84 + 85 85 + static void _cifs_mid_q_entry_release(struct kref *refcount) 86 86 + { 87 87 + struct mid_q_entry *mid = container_of(refcount, struct mid_q_entry, 88 88 + refcount); 89 89 + 90 90 + mempool_free(mid, cifs_mid_poolp); 91 91 + } 92 92 + 93 93 + void cifs_mid_q_entry_release(struct mid_q_entry *midEntry) 94 94 + { 95 95 + spin_lock(&GlobalMid_Lock); 96 96 + kref_put(&midEntry->refcount, _cifs_mid_q_entry_release); 97 97 + spin_unlock(&GlobalMid_Lock); 84 98 } 85 99 86 100 void ··· 126 110 } 127 111 } 128 112 #endif 129 129 - mempool_free(midEntry, cifs_mid_poolp); 113 113 + cifs_mid_q_entry_release(midEntry); 130 114 } 131 115 132 116 void ··· 218 202 } 219 203 220 204 unsigned long 221 221 - smb2_rqst_len(struct smb_rqst *rqst, bool skip_rfc1002_marker) 205 205 + smb_rqst_len(struct TCP_Server_Info *server, struct smb_rqst *rqst) 222 206 { 223 207 unsigned int i; 224 208 struct kvec *iov; 225 209 int nvec; 226 210 unsigned long buflen = 0; 227 211 228 228 - if (skip_rfc1002_marker && rqst->rq_iov[0].iov_len == 4) { 212 212 + if (server->vals->header_preamble_size == 0 && 213 213 + rqst->rq_nvec >= 2 && rqst->rq_iov[0].iov_len == 4) { 229 214 iov = &rqst->rq_iov[1]; 230 215 nvec = rqst->rq_nvec - 1; 231 216 } else { ··· 277 260 __be32 rfc1002_marker; 278 261 279 262 if (cifs_rdma_enabled(server) && server->smbd_conn) { 280 280 - rc = smbd_send(server->smbd_conn, rqst); 263 263 + rc = smbd_send(server, rqst); 281 264 goto smbd_done; 282 265 } 283 266 if (ssocket == NULL) ··· 288 271 (char *)&val, sizeof(val)); 289 272 290 273 for (j = 0; j < num_rqst; j++) 291 291 - send_length += smb2_rqst_len(&rqst[j], true); 274 274 + send_length += smb_rqst_len(server, &rqst[j]); 292 275 rfc1002_marker = cpu_to_be32(send_length); 293 276 294 277 /* Generate a rfc1002 marker for SMB2+ */