tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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

Pull more cifs updates from Steve French:
"Fixes from the recent SMB3 Test events and Storage Developer
Conference (held the last two weeks).

Here are nine smb3 patches including an important patch for debugging
traces with wireshark, with three patches marked for stable.

Additional fixes from last week to better handle some newly discovered
reparse points, and a fix the create/mkdir path for setting the mode
more atomically (in SMB3 Create security descriptor context), and one
for path name processing are still being tested so are not included
here"

* tag '5.4-rc-smb3-fixes' of git://git.samba.org/sfrench/cifs-2.6:
CIFS: Fix oplock handling for SMB 2.1+ protocols
smb3: missing ACL related flags
smb3: pass mode bits into create calls
smb3: Add missing reparse tags
CIFS: fix max ea value size
fs/cifs/sess.c: Remove set but not used variable 'capabilities'
fs/cifs/smb2pdu.c: Make SMB2_notify_init static
smb3: fix leak in "open on server" perf counter
smb3: allow decryption keys to be dumped by admin for debugging

Linus Torvalds 7edee522 3f2dc279

+194 -26
+9
fs/cifs/cifs_ioctl.h
··· 57 57 /* char buffer[]; */ 58 58 } __packed; 59 59 60 + struct smb3_key_debug_info { 61 + __u64 Suid; 62 + __u16 cipher_type; 63 + __u8 auth_key[16]; /* SMB2_NTLMV2_SESSKEY_SIZE */ 64 + __u8 smb3encryptionkey[SMB3_SIGN_KEY_SIZE]; 65 + __u8 smb3decryptionkey[SMB3_SIGN_KEY_SIZE]; 66 + } __packed; 67 + 60 68 #define CIFS_IOCTL_MAGIC 0xCF 61 69 #define CIFS_IOC_COPYCHUNK_FILE _IOW(CIFS_IOCTL_MAGIC, 3, int) 62 70 #define CIFS_IOC_SET_INTEGRITY _IO(CIFS_IOCTL_MAGIC, 4) 63 71 #define CIFS_IOC_GET_MNT_INFO _IOR(CIFS_IOCTL_MAGIC, 5, struct smb_mnt_fs_info) 64 72 #define CIFS_ENUMERATE_SNAPSHOTS _IOR(CIFS_IOCTL_MAGIC, 6, struct smb_snapshot_array) 65 73 #define CIFS_QUERY_INFO _IOWR(CIFS_IOCTL_MAGIC, 7, struct smb_query_info) 74 + #define CIFS_DUMP_KEY _IOWR(CIFS_IOCTL_MAGIC, 8, struct smb3_key_debug_info)
+80 -1
fs/cifs/cifsacl.h
··· 90 90 __le32 num_aces; 91 91 } __attribute__((packed)); 92 92 93 + /* ACE types - see MS-DTYP 2.4.4.1 */ 94 + #define ACCESS_ALLOWED_ACE_TYPE 0x00 95 + #define ACCESS_DENIED_ACE_TYPE 0x01 96 + #define SYSTEM_AUDIT_ACE_TYPE 0x02 97 + #define SYSTEM_ALARM_ACE_TYPE 0x03 98 + #define ACCESS_ALLOWED_COMPOUND_ACE_TYPE 0x04 99 + #define ACCESS_ALLOWED_OBJECT_ACE_TYPE 0x05 100 + #define ACCESS_DENIED_OBJECT_ACE_TYPE 0x06 101 + #define SYSTEM_AUDIT_OBJECT_ACE_TYPE 0x07 102 + #define SYSTEM_ALARM_OBJECT_ACE_TYPE 0x08 103 + #define ACCESS_ALLOWED_CALLBACK_ACE_TYPE 0x09 104 + #define ACCESS_DENIED_CALLBACK_ACE_TYPE 0x0A 105 + #define ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE 0x0B 106 + #define ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE 0x0C 107 + #define SYSTEM_AUDIT_CALLBACK_ACE_TYPE 0x0D 108 + #define SYSTEM_ALARM_CALLBACK_ACE_TYPE 0x0E /* Reserved */ 109 + #define SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE 0x0F 110 + #define SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE 0x10 /* reserved */ 111 + #define SYSTEM_MANDATORY_LABEL_ACE_TYPE 0x11 112 + #define SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE 0x12 113 + #define SYSTEM_SCOPED_POLICY_ID_ACE_TYPE 0x13 114 + 115 + /* ACE flags */ 116 + #define OBJECT_INHERIT_ACE 0x01 117 + #define CONTAINER_INHERIT_ACE 0x02 118 + #define NO_PROPAGATE_INHERIT_ACE 0x04 119 + #define INHERIT_ONLY_ACE 0x08 120 + #define INHERITED_ACE 0x10 121 + #define SUCCESSFUL_ACCESS_ACE_FLAG 0x40 122 + #define FAILED_ACCESS_ACE_FLAG 0x80 123 + 93 124 struct cifs_ace { 94 - __u8 type; 125 + __u8 type; /* see above and MS-DTYP 2.4.4.1 */ 95 126 __u8 flags; 96 127 __le16 size; 97 128 __le32 access_req; 98 129 struct cifs_sid sid; /* ie UUID of user or group who gets these perms */ 99 130 } __attribute__((packed)); 131 + 132 + /* 133 + * The current SMB3 form of security descriptor is similar to what was used for 134 + * cifs (see above) but some fields are split, and fields in the struct below 135 + * matches names of fields to the the spec, MS-DTYP (see sections 2.4.5 and 136 + * 2.4.6). Note that "CamelCase" fields are used in this struct in order to 137 + * match the MS-DTYP and MS-SMB2 specs which define the wire format. 138 + */ 139 + struct smb3_sd { 140 + __u8 Revision; /* revision level, MUST be one */ 141 + __u8 Sbz1; /* only meaningful if 'RM' flag set below */ 142 + __le16 Control; 143 + __le32 OffsetOwner; 144 + __le32 OffsetGroup; 145 + __le32 OffsetSacl; 146 + __le32 OffsetDacl; 147 + } __packed; 148 + 149 + /* Meaning of 'Control' field flags */ 150 + #define ACL_CONTROL_SR 0x0001 /* Self relative */ 151 + #define ACL_CONTROL_RM 0x0002 /* Resource manager control bits */ 152 + #define ACL_CONTROL_PS 0x0004 /* SACL protected from inherits */ 153 + #define ACL_CONTROL_PD 0x0008 /* DACL protected from inherits */ 154 + #define ACL_CONTROL_SI 0x0010 /* SACL Auto-Inherited */ 155 + #define ACL_CONTROL_DI 0x0020 /* DACL Auto-Inherited */ 156 + #define ACL_CONTROL_SC 0x0040 /* SACL computed through inheritance */ 157 + #define ACL_CONTROL_DC 0x0080 /* DACL computed through inheritence */ 158 + #define ACL_CONTROL_SS 0x0100 /* Create server ACL */ 159 + #define ACL_CONTROL_DT 0x0200 /* DACL provided by trusteed source */ 160 + #define ACL_CONTROL_SD 0x0400 /* SACL defaulted */ 161 + #define ACL_CONTROL_SP 0x0800 /* SACL is present on object */ 162 + #define ACL_CONTROL_DD 0x1000 /* DACL defaulted */ 163 + #define ACL_CONTROL_DP 0x2000 /* DACL is present on object */ 164 + #define ACL_CONTROL_GD 0x4000 /* Group was defaulted */ 165 + #define ACL_CONTROL_OD 0x8000 /* User was defaulted */ 166 + 167 + /* Meaning of AclRevision flags */ 168 + #define ACL_REVISION 0x02 /* See section 2.4.4.1 of MS-DTYP */ 169 + #define ACL_REVISION_DS 0x04 /* Additional AceTypes allowed */ 170 + 171 + struct smb3_acl { 172 + u8 AclRevision; /* revision level */ 173 + u8 Sbz1; /* MBZ */ 174 + __le16 AclSize; 175 + __le16 AceCount; 176 + __le16 Sbz2; /* MBZ */ 177 + } __packed; 178 + 100 179 101 180 /* 102 181 * Minimum security identifier can be one for system defined Users
+4 -2
fs/cifs/cifsglob.h
··· 331 331 umode_t mode, struct cifs_tcon *tcon, 332 332 const char *full_path, 333 333 struct cifs_sb_info *cifs_sb); 334 - int (*mkdir)(const unsigned int, struct cifs_tcon *, const char *, 335 - struct cifs_sb_info *); 334 + int (*mkdir)(const unsigned int xid, struct inode *inode, umode_t mode, 335 + struct cifs_tcon *tcon, const char *name, 336 + struct cifs_sb_info *sb); 336 337 /* set info on created directory */ 337 338 void (*mkdir_setinfo)(struct inode *, const char *, 338 339 struct cifs_sb_info *, struct cifs_tcon *, ··· 1210 1209 bool smallBuf:1; /* so we know which buf_release function to call */ 1211 1210 }; 1212 1211 1212 + #define ACL_NO_MODE -1 1213 1213 struct cifs_open_parms { 1214 1214 struct cifs_tcon *tcon; 1215 1215 struct cifs_sb_info *cifs_sb;
+2 -1
fs/cifs/cifsproto.h
··· 372 372 const struct nls_table *nls_codepage, 373 373 int remap); 374 374 375 - extern int CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, 375 + extern int CIFSSMBMkDir(const unsigned int xid, struct inode *inode, 376 + umode_t mode, struct cifs_tcon *tcon, 376 377 const char *name, struct cifs_sb_info *cifs_sb); 377 378 extern int CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, 378 379 const char *name, struct cifs_sb_info *cifs_sb);
+2 -1
fs/cifs/cifssmb.c
··· 1078 1078 } 1079 1079 1080 1080 int 1081 - CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name, 1081 + CIFSSMBMkDir(const unsigned int xid, struct inode *inode, umode_t mode, 1082 + struct cifs_tcon *tcon, const char *name, 1082 1083 struct cifs_sb_info *cifs_sb) 1083 1084 { 1084 1085 int rc = 0;
+2 -1
fs/cifs/inode.c
··· 1622 1622 } 1623 1623 1624 1624 /* BB add setting the equivalent of mode via CreateX w/ACLs */ 1625 - rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb); 1625 + rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb); 1626 1626 if (rc) { 1627 1627 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc); 1628 1628 d_drop(direntry); 1629 1629 goto mkdir_out; 1630 1630 } 1631 1631 1632 + /* TODO: skip this for smb2/smb3 */ 1632 1633 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon, 1633 1634 xid); 1634 1635 mkdir_out:
+29
fs/cifs/ioctl.c
··· 164 164 long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) 165 165 { 166 166 struct inode *inode = file_inode(filep); 167 + struct smb3_key_debug_info pkey_inf; 167 168 int rc = -ENOTTY; /* strange error - but the precedent */ 168 169 unsigned int xid; 169 170 struct cifsFileInfo *pSMBFile = filep->private_data; ··· 270 269 pSMBFile, (void __user *)arg); 271 270 else 272 271 rc = -EOPNOTSUPP; 272 + break; 273 + case CIFS_DUMP_KEY: 274 + if (pSMBFile == NULL) 275 + break; 276 + if (!capable(CAP_SYS_ADMIN)) { 277 + rc = -EACCES; 278 + break; 279 + } 280 + 281 + tcon = tlink_tcon(pSMBFile->tlink); 282 + if (!smb3_encryption_required(tcon)) { 283 + rc = -EOPNOTSUPP; 284 + break; 285 + } 286 + pkey_inf.cipher_type = 287 + le16_to_cpu(tcon->ses->server->cipher_type); 288 + pkey_inf.Suid = tcon->ses->Suid; 289 + memcpy(pkey_inf.auth_key, tcon->ses->auth_key.response, 290 + 16 /* SMB2_NTLMV2_SESSKEY_SIZE */); 291 + memcpy(pkey_inf.smb3decryptionkey, 292 + tcon->ses->smb3decryptionkey, SMB3_SIGN_KEY_SIZE); 293 + memcpy(pkey_inf.smb3encryptionkey, 294 + tcon->ses->smb3encryptionkey, SMB3_SIGN_KEY_SIZE); 295 + if (copy_to_user((void __user *)arg, &pkey_inf, 296 + sizeof(struct smb3_key_debug_info))) 297 + rc = -EFAULT; 298 + else 299 + rc = 0; 273 300 break; 274 301 default: 275 302 cifs_dbg(FYI, "unsupported ioctl\n");
+1 -2
fs/cifs/sess.c
··· 698 698 char *bcc_ptr; 699 699 struct cifs_ses *ses = sess_data->ses; 700 700 char lnm_session_key[CIFS_AUTH_RESP_SIZE]; 701 - __u32 capabilities; 702 701 __u16 bytes_remaining; 703 702 704 703 /* lanman 2 style sessionsetup */ ··· 708 709 709 710 pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base; 710 711 bcc_ptr = sess_data->iov[2].iov_base; 711 - capabilities = cifs_ssetup_hdr(ses, pSMB); 712 + (void)cifs_ssetup_hdr(ses, pSMB); 712 713 713 714 pSMB->req.hdr.Flags2 &= ~SMBFLG2_UNICODE; 714 715
+19 -15
fs/cifs/smb2inode.c
··· 51 51 smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon, 52 52 struct cifs_sb_info *cifs_sb, const char *full_path, 53 53 __u32 desired_access, __u32 create_disposition, 54 - __u32 create_options, void *ptr, int command, 54 + __u32 create_options, umode_t mode, void *ptr, int command, 55 55 struct cifsFileInfo *cfile) 56 56 { 57 57 int rc; ··· 103 103 oparms.create_options |= CREATE_OPEN_BACKUP_INTENT; 104 104 oparms.fid = &fid; 105 105 oparms.reconnect = false; 106 + oparms.mode = mode; 106 107 107 108 memset(&open_iov, 0, sizeof(open_iov)); 108 109 rqst[num_rqst].rq_iov = open_iov; ··· 479 478 cifs_get_readable_path(tcon, full_path, &cfile); 480 479 rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, 481 480 FILE_READ_ATTRIBUTES, FILE_OPEN, create_options, 482 - smb2_data, SMB2_OP_QUERY_INFO, cfile); 481 + ACL_NO_MODE, smb2_data, SMB2_OP_QUERY_INFO, cfile); 483 482 if (rc == -EOPNOTSUPP) { 484 483 *symlink = true; 485 484 create_options |= OPEN_REPARSE_POINT; ··· 487 486 /* Failed on a symbolic link - query a reparse point info */ 488 487 rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, 489 488 FILE_READ_ATTRIBUTES, FILE_OPEN, 490 - create_options, smb2_data, 491 - SMB2_OP_QUERY_INFO, NULL); 489 + create_options, ACL_NO_MODE, 490 + smb2_data, SMB2_OP_QUERY_INFO, NULL); 492 491 } 493 492 if (rc) 494 493 goto out; ··· 500 499 } 501 500 502 501 int 503 - smb2_mkdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name, 502 + smb2_mkdir(const unsigned int xid, struct inode *parent_inode, umode_t mode, 503 + struct cifs_tcon *tcon, const char *name, 504 504 struct cifs_sb_info *cifs_sb) 505 505 { 506 506 return smb2_compound_op(xid, tcon, cifs_sb, name, 507 507 FILE_WRITE_ATTRIBUTES, FILE_CREATE, 508 - CREATE_NOT_FILE, NULL, SMB2_OP_MKDIR, NULL); 508 + CREATE_NOT_FILE, mode, NULL, SMB2_OP_MKDIR, 509 + NULL); 509 510 } 510 511 511 512 void ··· 528 525 cifs_get_writable_path(tcon, name, &cfile); 529 526 tmprc = smb2_compound_op(xid, tcon, cifs_sb, name, 530 527 FILE_WRITE_ATTRIBUTES, FILE_CREATE, 531 - CREATE_NOT_FILE, &data, SMB2_OP_SET_INFO, 532 - cfile); 528 + CREATE_NOT_FILE, ACL_NO_MODE, 529 + &data, SMB2_OP_SET_INFO, cfile); 533 530 if (tmprc == 0) 534 531 cifs_i->cifsAttrs = dosattrs; 535 532 } ··· 539 536 struct cifs_sb_info *cifs_sb) 540 537 { 541 538 return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN, 542 - CREATE_NOT_FILE, 539 + CREATE_NOT_FILE, ACL_NO_MODE, 543 540 NULL, SMB2_OP_RMDIR, NULL); 544 541 } 545 542 ··· 549 546 { 550 547 return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN, 551 548 CREATE_DELETE_ON_CLOSE | OPEN_REPARSE_POINT, 552 - NULL, SMB2_OP_DELETE, NULL); 549 + ACL_NO_MODE, NULL, SMB2_OP_DELETE, NULL); 553 550 } 554 551 555 552 static int ··· 567 564 goto smb2_rename_path; 568 565 } 569 566 rc = smb2_compound_op(xid, tcon, cifs_sb, from_name, access, 570 - FILE_OPEN, 0, smb2_to_name, command, cfile); 567 + FILE_OPEN, 0, ACL_NO_MODE, smb2_to_name, 568 + command, cfile); 571 569 smb2_rename_path: 572 570 kfree(smb2_to_name); 573 571 return rc; ··· 605 601 __le64 eof = cpu_to_le64(size); 606 602 607 603 return smb2_compound_op(xid, tcon, cifs_sb, full_path, 608 - FILE_WRITE_DATA, FILE_OPEN, 0, &eof, 609 - SMB2_OP_SET_EOF, NULL); 604 + FILE_WRITE_DATA, FILE_OPEN, 0, ACL_NO_MODE, 605 + &eof, SMB2_OP_SET_EOF, NULL); 610 606 } 611 607 612 608 int ··· 627 623 return PTR_ERR(tlink); 628 624 629 625 rc = smb2_compound_op(xid, tlink_tcon(tlink), cifs_sb, full_path, 630 - FILE_WRITE_ATTRIBUTES, FILE_OPEN, 0, buf, 631 - SMB2_OP_SET_INFO, NULL); 626 + FILE_WRITE_ATTRIBUTES, FILE_OPEN, 627 + 0, ACL_NO_MODE, buf, SMB2_OP_SET_INFO, NULL); 632 628 cifs_put_tlink(tlink); 633 629 return rc; 634 630 }
+10
fs/cifs/smb2ops.c
··· 751 751 goto oshr_exit; 752 752 } 753 753 754 + atomic_inc(&tcon->num_remote_opens); 755 + 754 756 o_rsp = (struct smb2_create_rsp *)rsp_iov[0].iov_base; 755 757 oparms.fid->persistent_fid = o_rsp->PersistentFileId; 756 758 oparms.fid->volatile_fid = o_rsp->VolatileFileId; ··· 1178 1176 1179 1177 rc = compound_send_recv(xid, ses, flags, 3, rqst, 1180 1178 resp_buftype, rsp_iov); 1179 + /* no need to bump num_remote_opens because handle immediately closed */ 1181 1180 1182 1181 sea_exit: 1183 1182 kfree(ea); ··· 1521 1518 resp_buftype, rsp_iov); 1522 1519 if (rc) 1523 1520 goto iqinf_exit; 1521 + 1522 + /* No need to bump num_remote_opens since handle immediately closed */ 1524 1523 if (qi.flags & PASSTHRU_FSCTL) { 1525 1524 pqi = (struct smb_query_info __user *)arg; 1526 1525 io_rsp = (struct smb2_ioctl_rsp *)rsp_iov[1].iov_base; ··· 3332 3327 oplock &= 0xFF; 3333 3328 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE) 3334 3329 return; 3330 + 3331 + /* Check if the server granted an oplock rather than a lease */ 3332 + if (oplock & SMB2_OPLOCK_LEVEL_EXCLUSIVE) 3333 + return smb2_set_oplock_level(cinode, oplock, epoch, 3334 + purge_cache); 3335 3335 3336 3336 if (oplock & SMB2_LEASE_READ_CACHING_HE) { 3337 3337 new_oplock |= CIFS_CACHE_READ_FLG;
+22 -1
fs/cifs/smb2pdu.c
··· 751 751 unsigned int num = *num_iovec; 752 752 753 753 iov[num].iov_base = create_posix_buf(mode); 754 + if (mode == -1) 755 + cifs_dbg(VFS, "illegal mode\n"); /* BB REMOVEME */ 754 756 if (iov[num].iov_base == NULL) 755 757 return -ENOMEM; 756 758 iov[num].iov_len = sizeof(struct create_posix); ··· 2354 2352 rqst.rq_iov = iov; 2355 2353 rqst.rq_nvec = n_iov; 2356 2354 2355 + /* no need to inc num_remote_opens because we close it just below */ 2357 2356 trace_smb3_posix_mkdir_enter(xid, tcon->tid, ses->Suid, CREATE_NOT_FILE, 2358 2357 FILE_WRITE_ATTRIBUTES); 2359 2358 /* resource #4: response buffer */ ··· 2419 2416 /* File attributes ignored on open (used in create though) */ 2420 2417 req->FileAttributes = cpu_to_le32(file_attributes); 2421 2418 req->ShareAccess = FILE_SHARE_ALL_LE; 2419 + 2422 2420 req->CreateDisposition = cpu_to_le32(oparms->disposition); 2423 2421 req->CreateOptions = cpu_to_le32(oparms->create_options & CREATE_OPTIONS_MASK); 2424 2422 req->NameOffset = cpu_to_le16(sizeof(struct smb2_create_req)); ··· 2517 2513 } 2518 2514 2519 2515 rc = add_twarp_context(iov, &n_iov, tcon->snapshot_time); 2516 + if (rc) 2517 + return rc; 2518 + } 2519 + 2520 + /* TODO: add handling for the mode on create */ 2521 + if (oparms->disposition == FILE_CREATE) 2522 + cifs_dbg(VFS, "mode is 0x%x\n", oparms->mode); /* BB REMOVEME */ 2523 + 2524 + if ((oparms->disposition == FILE_CREATE) && (oparms->mode != -1)) { 2525 + if (n_iov > 2) { 2526 + struct create_context *ccontext = 2527 + (struct create_context *)iov[n_iov-1].iov_base; 2528 + ccontext->Next = 2529 + cpu_to_le32(iov[n_iov-1].iov_len); 2530 + } 2531 + 2532 + /* rc = add_sd_context(iov, &n_iov, oparms->mode); */ 2520 2533 if (rc) 2521 2534 return rc; 2522 2535 } ··· 3201 3180 * See MS-SMB2 2.2.35 and 2.2.36 3202 3181 */ 3203 3182 3204 - int 3183 + static int 3205 3184 SMB2_notify_init(const unsigned int xid, struct smb_rqst *rqst, 3206 3185 struct cifs_tcon *tcon, u64 persistent_fid, u64 volatile_fid, 3207 3186 u32 completion_filter, bool watch_tree)
+2 -1
fs/cifs/smb2proto.h
··· 84 84 umode_t mode, struct cifs_tcon *tcon, 85 85 const char *full_path, 86 86 struct cifs_sb_info *cifs_sb); 87 - extern int smb2_mkdir(const unsigned int xid, struct cifs_tcon *tcon, 87 + extern int smb2_mkdir(const unsigned int xid, struct inode *inode, 88 + umode_t mode, struct cifs_tcon *tcon, 88 89 const char *name, struct cifs_sb_info *cifs_sb); 89 90 extern void smb2_mkdir_setinfo(struct inode *inode, const char *full_path, 90 91 struct cifs_sb_info *cifs_sb,
+11
fs/cifs/smbfsctl.h
··· 144 144 #define IO_REPARSE_APPXSTREAM 0xC0000014 145 145 /* NFS symlinks, Win 8/SMB3 and later */ 146 146 #define IO_REPARSE_TAG_NFS 0x80000014 147 + /* 148 + * AzureFileSync - see 149 + * https://docs.microsoft.com/en-us/azure/storage/files/storage-sync-cloud-tiering 150 + */ 151 + #define IO_REPARSE_TAG_AZ_FILE_SYNC 0x8000001e 152 + /* WSL reparse tags */ 153 + #define IO_REPARSE_TAG_LX_SYMLINK 0xA000001D 154 + #define IO_REPARSE_TAG_AF_UNIX 0x80000023 155 + #define IO_REPARSE_TAG_LX_FIFO 0x80000024 156 + #define IO_REPARSE_TAG_LX_CHR 0x80000025 157 + #define IO_REPARSE_TAG_LX_BLK 0x80000026 147 158 148 159 /* fsctl flags */ 149 160 /* If Flags is set to this value, the request is an FSCTL not ioctl request */
+1 -1
fs/cifs/xattr.c
··· 31 31 #include "cifs_fs_sb.h" 32 32 #include "cifs_unicode.h" 33 33 34 - #define MAX_EA_VALUE_SIZE 65535 34 + #define MAX_EA_VALUE_SIZE CIFSMaxBufSize 35 35 #define CIFS_XATTR_CIFS_ACL "system.cifs_acl" 36 36 #define CIFS_XATTR_ATTRIB "cifs.dosattrib" /* full name: user.cifs.dosattrib */ 37 37 #define CIFS_XATTR_CREATETIME "cifs.creationtime" /* user.cifs.creationtime */