Merge tag 'v7.1-rc1-part2-smb3-client-fixes' of git://git.samba.org/sfrench/cifs-2.6

+2 -2

MAINTAINERS

··· 6386 6386 L: samba-technical@lists.samba.org (moderated for non-subscribers) 6387 6387 S: Supported 6388 6388 W: https://wiki.samba.org/index.php/LinuxCIFS 6389 - T: git git://git.samba.org/sfrench/cifs-2.6.git 6389 + T: git https://git.samba.org/sfrench/cifs-2.6.git 6390 6390 F: Documentation/admin-guide/cifs/ 6391 6391 F: fs/smb/client/ 6392 6392 F: fs/smb/common/ ··· 14007 14007 R: Tom Talpey <tom@talpey.com> 14008 14008 L: linux-cifs@vger.kernel.org 14009 14009 S: Maintained 14010 - T: git git://git.samba.org/ksmbd.git 14010 + T: git https://git.samba.org/ksmbd.git 14011 14011 F: Documentation/filesystems/smb/ksmbd.rst 14012 14012 F: fs/smb/common/ 14013 14013 F: fs/smb/server/

+9 -5

fs/dcache.c

··· 3196 3196 } 3197 3197 EXPORT_SYMBOL(d_mark_tmpfile); 3198 3198 3199 - void d_mark_tmpfile_name(struct file *file, const struct qstr *name) 3199 + int d_mark_tmpfile_name(struct file *file, const struct qstr *name) 3200 3200 { 3201 3201 struct dentry *dentry = file->f_path.dentry; 3202 3202 char *dname = dentry->d_shortname.string; 3203 3203 3204 - BUG_ON(dname_external(dentry)); 3205 - BUG_ON(d_really_is_positive(dentry)); 3206 - BUG_ON(!d_unlinked(dentry)); 3207 - BUG_ON(name->len > DNAME_INLINE_LEN - 1); 3204 + if (unlikely(dname_external(dentry) || 3205 + d_really_is_positive(dentry) || 3206 + !d_unlinked(dentry))) 3207 + return -EINVAL; 3208 + if (unlikely(name->len > DNAME_INLINE_LEN - 1)) 3209 + return -ENAMETOOLONG; 3210 + 3208 3211 spin_lock(&dentry->d_parent->d_lock); 3209 3212 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 3210 3213 dentry->__d_name.len = name->len; ··· 3215 3212 dname[name->len] = '\0'; 3216 3213 spin_unlock(&dentry->d_lock); 3217 3214 spin_unlock(&dentry->d_parent->d_lock); 3215 + return 0; 3218 3216 } 3219 3217 EXPORT_SYMBOL(d_mark_tmpfile_name); 3220 3218

+5 -10

fs/smb/client/cifsfs.h

··· 10 10 #define _CIFSFS_H 11 11 12 12 #include <linux/hash.h> 13 + #include <linux/dcache.h> 13 14 14 15 #define ROOT_I 2 15 16 ··· 150 149 151 150 char *cifs_silly_fullpath(struct dentry *dentry); 152 151 153 - #define CIFS_TMPNAME_PREFIX ".__smbfile_tmp" 154 - #define CIFS_TMPNAME_PREFIX_LEN ((int)sizeof(CIFS_TMPNAME_PREFIX) - 1) 155 - #define CIFS_TMPNAME_COUNTER_LEN ((int)sizeof(cifs_tmpcounter) * 2) 156 - #define CIFS_TMPNAME_LEN \ 157 - (CIFS_TMPNAME_PREFIX_LEN + CIFS_TMPNAME_COUNTER_LEN) 152 + #define CIFS_TMPNAME_PREFIX ".__smbfile_tmp" 153 + #define CIFS_TMPNAME_LEN (DNAME_INLINE_LEN - 1) 158 154 159 - #define CIFS_SILLYNAME_PREFIX ".__smbfile_silly" 160 - #define CIFS_SILLYNAME_PREFIX_LEN ((int)sizeof(CIFS_SILLYNAME_PREFIX) - 1) 161 - #define CIFS_SILLYNAME_COUNTER_LEN ((int)sizeof(cifs_sillycounter) * 2) 162 - #define CIFS_SILLYNAME_LEN \ 163 - (CIFS_SILLYNAME_PREFIX_LEN + CIFS_SILLYNAME_COUNTER_LEN) 155 + #define CIFS_SILLYNAME_PREFIX ".__smbfile_silly" 156 + #define CIFS_SILLYNAME_LEN (DNAME_INLINE_LEN - 1) 164 157 165 158 #ifdef CONFIG_CIFS_NFSD_EXPORT 166 159 extern const struct export_operations cifs_export_ops;

+15 -10

fs/smb/client/dir.c

··· 1056 1056 { 1057 1057 struct dentry *dentry = file->f_path.dentry; 1058 1058 struct cifs_sb_info *cifs_sb = CIFS_SB(dir); 1059 + size_t namesize = CIFS_TMPNAME_LEN + 1; 1059 1060 char *path __free(kfree) = NULL, *name; 1060 1061 unsigned int oflags = file->f_flags; 1061 - size_t size = CIFS_TMPNAME_LEN + 1; 1062 1062 int retries = 0, max_retries = 16; 1063 1063 struct TCP_Server_Info *server; 1064 1064 struct cifs_pending_open open; ··· 1070 1070 struct inode *inode; 1071 1071 unsigned int xid; 1072 1072 __u32 oplock; 1073 + int namelen; 1073 1074 int rc; 1074 1075 1075 1076 if (unlikely(cifs_forced_shutdown(cifs_sb))) ··· 1094 1093 server->ops->new_lease_key(&fid); 1095 1094 cifs_add_pending_open(&fid, tlink, &open); 1096 1095 1097 - path = alloc_parent_path(dentry, size - 1); 1096 + path = alloc_parent_path(dentry, namesize - 1); 1098 1097 if (IS_ERR(path)) { 1099 1098 cifs_del_pending_open(&open); 1100 1099 rc = PTR_ERR(path); ··· 1104 1103 1105 1104 name = path + strlen(path); 1106 1105 do { 1107 - scnprintf(name, size, 1108 - CIFS_TMPNAME_PREFIX "%0*x", 1109 - CIFS_TMPNAME_COUNTER_LEN, 1110 - atomic_inc_return(&cifs_tmpcounter)); 1106 + /* Append tmpfile name to @path */ 1107 + namelen = scnprintf(name, namesize, CIFS_TMPNAME_PREFIX "%x", 1108 + atomic_inc_return(&cifs_tmpcounter)); 1111 1109 rc = __cifs_do_create(dir, dentry, path, xid, tlink, oflags, 1112 1110 mode, &oplock, &fid, NULL, &inode); 1113 1111 if (!rc) { 1112 + rc = d_mark_tmpfile_name(file, &QSTR_LEN(name, namelen)); 1113 + if (rc) { 1114 + cifs_dbg(VFS | ONCE, "%s: failed to set filename in dentry: %d\n", 1115 + __func__, rc); 1116 + rc = -EISDIR; 1117 + iput(inode); 1118 + goto err_open; 1119 + } 1114 1120 set_nlink(inode, 0); 1115 1121 mark_inode_dirty(inode); 1116 - d_mark_tmpfile_name(file, &QSTR_LEN(name, size - 1)); 1117 1122 d_instantiate(dentry, inode); 1118 1123 break; 1119 1124 } ··· 1175 1168 1176 1169 do { 1177 1170 dput(sdentry); 1178 - scnprintf(name, namesize, 1179 - CIFS_SILLYNAME_PREFIX "%0*x", 1180 - CIFS_SILLYNAME_COUNTER_LEN, 1171 + scnprintf(name, namesize, CIFS_SILLYNAME_PREFIX "%x", 1181 1172 atomic_inc_return(&cifs_sillycounter)); 1182 1173 sdentry = lookup_noperm(&QSTR(name), dentry->d_parent); 1183 1174 if (IS_ERR(sdentry))

+19 -2

fs/smb/client/file.c

··· 1082 1082 rc = cfile ? 0 : -ENOENT; 1083 1083 } 1084 1084 if (rc == 0) { 1085 + trace_smb3_open_cached(xid, tcon->tid, tcon->ses->Suid, 1086 + cfile->fid.persistent_fid, 1087 + file->f_flags, cfile->f_flags); 1085 1088 file->private_data = cfile; 1086 1089 spin_lock(&CIFS_I(inode)->deferred_lock); 1087 1090 cifs_del_deferred_close(cfile); ··· 1444 1441 struct cifsInodeInfo *cinode = CIFS_I(inode); 1445 1442 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1446 1443 struct cifs_deferred_close *dclose; 1444 + struct cifs_tcon *tcon; 1447 1445 1448 1446 cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE); 1449 1447 ··· 1471 1467 cifsFileInfo_get(cfile); 1472 1468 } else { 1473 1469 /* Deferred close for files */ 1470 + tcon = tlink_tcon(cfile->tlink); 1471 + trace_smb3_close_cached(tcon->tid, tcon->ses->Suid, 1472 + cfile->fid.persistent_fid, 1473 + cifs_sb->ctx->closetimeo); 1474 1474 queue_delayed_work(deferredclose_wq, 1475 1475 &cfile->deferred, cifs_sb->ctx->closetimeo); 1476 1476 cfile->deferred_close_scheduled = true; ··· 1638 1630 continue; 1639 1631 if (conf_lock) 1640 1632 *conf_lock = li; 1633 + trace_smb3_lock_conflict(cfile->fid.persistent_fid, 1634 + offset, length, type, 1635 + li->offset, li->length, li->type, li->pid); 1641 1636 return true; 1642 1637 } 1643 1638 return false; ··· 1722 1711 */ 1723 1712 static int 1724 1713 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock, 1725 - bool wait) 1714 + bool wait, unsigned int xid) 1726 1715 { 1727 1716 struct cifsLockInfo *conf_lock; 1728 1717 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); ··· 1737 1726 lock->type, lock->flags, &conf_lock, 1738 1727 CIFS_LOCK_OP); 1739 1728 if (!exist && cinode->can_cache_brlcks) { 1729 + struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1730 + 1740 1731 list_add_tail(&lock->llist, &cfile->llist->locks); 1732 + trace_smb3_lock_cached(xid, cfile->fid.persistent_fid, 1733 + tcon->tid, tcon->ses->Suid, 1734 + lock->offset, lock->length, 1735 + lock->type, 1, 0); 1741 1736 up_write(&cinode->lock_sem); 1742 1737 return rc; 1743 1738 } ··· 2358 2341 if (!lock) 2359 2342 return -ENOMEM; 2360 2343 2361 - rc = cifs_lock_add_if(cfile, lock, wait_flag); 2344 + rc = cifs_lock_add_if(cfile, lock, wait_flag, xid); 2362 2345 if (rc < 0) { 2363 2346 kfree(lock); 2364 2347 return rc;

+8

fs/smb/client/smb2ops.c

··· 4943 4943 goto free_dw; 4944 4944 server->total_read += rc; 4945 4945 4946 + if (le32_to_cpu(tr_hdr->OriginalMessageSize) < 4947 + server->vals->read_rsp_size) { 4948 + cifs_server_dbg(VFS, "OriginalMessageSize %u too small for read response (%zu)\n", 4949 + le32_to_cpu(tr_hdr->OriginalMessageSize), 4950 + server->vals->read_rsp_size); 4951 + rc = -EINVAL; 4952 + goto discard_data; 4953 + } 4946 4954 len = le32_to_cpu(tr_hdr->OriginalMessageSize) - 4947 4955 server->vals->read_rsp_size; 4948 4956 dw->len = len;

+20 -5

fs/smb/client/smb2pdu.c

··· 3043 3043 } 3044 3044 3045 3045 trace_smb3_posix_mkdir_done(xid, rsp->PersistentFileId, tcon->tid, ses->Suid, 3046 - CREATE_NOT_FILE, FILE_WRITE_ATTRIBUTES); 3046 + CREATE_NOT_FILE, FILE_WRITE_ATTRIBUTES, 3047 + rsp->OplockLevel); 3047 3048 3048 3049 SMB2_close(xid, tcon, rsp->PersistentFileId, rsp->VolatileFileId); 3049 3050 ··· 3321 3320 goto creat_exit; 3322 3321 } else if (rsp == NULL) /* unlikely to happen, but safer to check */ 3323 3322 goto creat_exit; 3324 - else 3325 - trace_smb3_open_done(xid, rsp->PersistentFileId, tcon->tid, ses->Suid, 3326 - oparms->create_options, oparms->desired_access); 3327 3323 3328 3324 atomic_inc(&tcon->num_remote_opens); 3329 3325 oparms->fid->persistent_fid = rsp->PersistentFileId; ··· 3345 3347 3346 3348 rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch, 3347 3349 oparms->fid->lease_key, oplock, buf, posix); 3350 + 3351 + trace_smb3_open_done(xid, rsp->PersistentFileId, tcon->tid, ses->Suid, 3352 + oparms->create_options, oparms->desired_access, 3353 + *oplock); 3348 3354 creat_exit: 3349 3355 SMB2_open_free(&rqst); 3350 3356 free_rsp_buf(resp_buftype, rsp); ··· 6274 6272 smb2_set_replay(server, &rqst); 6275 6273 } 6276 6274 6275 + trace_smb3_lock_enter(xid, persist_fid, tcon->tid, tcon->ses->Suid, 6276 + le64_to_cpu(buf[0].Offset), 6277 + le64_to_cpu(buf[0].Length), 6278 + le32_to_cpu(buf[0].Flags), num_lock, 0); 6279 + 6277 6280 rc = cifs_send_recv(xid, tcon->ses, server, 6278 6281 &rqst, &resp_buf_type, flags, 6279 6282 &rsp_iov); ··· 6287 6280 cifs_dbg(FYI, "Send error in smb2_lockv = %d\n", rc); 6288 6281 cifs_stats_fail_inc(tcon, SMB2_LOCK_HE); 6289 6282 trace_smb3_lock_err(xid, persist_fid, tcon->tid, 6290 - tcon->ses->Suid, rc); 6283 + tcon->ses->Suid, 6284 + le64_to_cpu(buf[0].Offset), 6285 + le64_to_cpu(buf[0].Length), 6286 + le32_to_cpu(buf[0].Flags), num_lock, rc); 6287 + } else { 6288 + trace_smb3_lock_done(xid, persist_fid, tcon->tid, tcon->ses->Suid, 6289 + le64_to_cpu(buf[0].Offset), 6290 + le64_to_cpu(buf[0].Length), 6291 + le32_to_cpu(buf[0].Flags), num_lock, 0); 6291 6292 } 6292 6293 6293 6294 if (is_replayable_error(rc) &&

+153 -7

fs/smb/client/trace.h

··· 670 670 TP_ARGS(xid, fid, tid, sesid, rc)) 671 671 672 672 DEFINE_SMB3_FD_ERR_EVENT(flush_err); 673 - DEFINE_SMB3_FD_ERR_EVENT(lock_err); 674 673 DEFINE_SMB3_FD_ERR_EVENT(close_err); 674 + 675 + DECLARE_EVENT_CLASS(smb3_lock_class, 676 + TP_PROTO(unsigned int xid, 677 + __u64 fid, 678 + __u32 tid, 679 + __u64 sesid, 680 + __u64 offset, 681 + __u64 len, 682 + __u32 flags, 683 + __u32 num_lock, 684 + int rc), 685 + TP_ARGS(xid, fid, tid, sesid, offset, len, flags, num_lock, rc), 686 + TP_STRUCT__entry( 687 + __field(unsigned int, xid) 688 + __field(__u64, fid) 689 + __field(__u32, tid) 690 + __field(__u64, sesid) 691 + __field(__u64, offset) 692 + __field(__u64, len) 693 + __field(__u32, flags) 694 + __field(__u32, num_lock) 695 + __field(int, rc) 696 + ), 697 + TP_fast_assign( 698 + __entry->xid = xid; 699 + __entry->fid = fid; 700 + __entry->tid = tid; 701 + __entry->sesid = sesid; 702 + __entry->offset = offset; 703 + __entry->len = len; 704 + __entry->flags = flags; 705 + __entry->num_lock = num_lock; 706 + __entry->rc = rc; 707 + ), 708 + TP_printk("xid=%u sid=0x%llx tid=0x%x fid=0x%llx offset=0x%llx len=0x%llx flags=0x%x num_lock=%u rc=%d", 709 + __entry->xid, __entry->sesid, __entry->tid, __entry->fid, 710 + __entry->offset, __entry->len, __entry->flags, __entry->num_lock, 711 + __entry->rc) 712 + ) 713 + 714 + #define DEFINE_SMB3_LOCK_EVENT(name) \ 715 + DEFINE_EVENT(smb3_lock_class, smb3_##name, \ 716 + TP_PROTO(unsigned int xid, \ 717 + __u64 fid, \ 718 + __u32 tid, \ 719 + __u64 sesid, \ 720 + __u64 offset, \ 721 + __u64 len, \ 722 + __u32 flags, \ 723 + __u32 num_lock, \ 724 + int rc), \ 725 + TP_ARGS(xid, fid, tid, sesid, offset, len, flags, num_lock, rc)) 726 + 727 + DEFINE_SMB3_LOCK_EVENT(lock_enter); 728 + DEFINE_SMB3_LOCK_EVENT(lock_done); 729 + DEFINE_SMB3_LOCK_EVENT(lock_err); 730 + DEFINE_SMB3_LOCK_EVENT(lock_cached); 731 + 732 + TRACE_EVENT(smb3_lock_conflict, 733 + TP_PROTO(__u64 fid, 734 + __u64 req_offset, 735 + __u64 req_len, 736 + __u8 req_type, 737 + __u64 conf_offset, 738 + __u64 conf_len, 739 + __u16 conf_type, 740 + __u32 conf_pid), 741 + TP_ARGS(fid, req_offset, req_len, req_type, conf_offset, conf_len, conf_type, conf_pid), 742 + TP_STRUCT__entry( 743 + __field(__u64, fid) 744 + __field(__u64, req_offset) 745 + __field(__u64, req_len) 746 + __field(__u8, req_type) 747 + __field(__u64, conf_offset) 748 + __field(__u64, conf_len) 749 + __field(__u16, conf_type) 750 + __field(__u32, conf_pid) 751 + ), 752 + TP_fast_assign( 753 + __entry->fid = fid; 754 + __entry->req_offset = req_offset; 755 + __entry->req_len = req_len; 756 + __entry->req_type = req_type; 757 + __entry->conf_offset = conf_offset; 758 + __entry->conf_len = conf_len; 759 + __entry->conf_type = conf_type; 760 + __entry->conf_pid = conf_pid; 761 + ), 762 + TP_printk("fid=0x%llx req=[0x%llx:0x%llx] type=0x%x conflicts with [0x%llx:0x%llx] type=0x%x pid=%u", 763 + __entry->fid, __entry->req_offset, __entry->req_len, __entry->req_type, 764 + __entry->conf_offset, __entry->conf_len, __entry->conf_type, __entry->conf_pid) 765 + ); 675 766 676 767 /* 677 768 * For handle based query/set info calls ··· 1321 1230 __u32 tid, 1322 1231 __u64 sesid, 1323 1232 int create_options, 1324 - int desired_access), 1325 - TP_ARGS(xid, fid, tid, sesid, create_options, desired_access), 1233 + int desired_access, 1234 + __u8 oplock), 1235 + TP_ARGS(xid, fid, tid, sesid, create_options, desired_access, oplock), 1326 1236 TP_STRUCT__entry( 1327 1237 __field(unsigned int, xid) 1328 1238 __field(__u64, fid) ··· 1331 1239 __field(__u64, sesid) 1332 1240 __field(int, create_options) 1333 1241 __field(int, desired_access) 1242 + __field(__u8, oplock) 1334 1243 ), 1335 1244 TP_fast_assign( 1336 1245 __entry->xid = xid; ··· 1340 1247 __entry->sesid = sesid; 1341 1248 __entry->create_options = create_options; 1342 1249 __entry->desired_access = desired_access; 1250 + __entry->oplock = oplock; 1343 1251 ), 1344 - TP_printk("xid=%u sid=0x%llx tid=0x%x fid=0x%llx cr_opts=0x%x des_access=0x%x", 1252 + TP_printk("xid=%u sid=0x%llx tid=0x%x fid=0x%llx cr_opts=0x%x des_access=0x%x oplock=0x%x", 1345 1253 __entry->xid, __entry->sesid, __entry->tid, __entry->fid, 1346 - __entry->create_options, __entry->desired_access) 1254 + __entry->create_options, __entry->desired_access, __entry->oplock) 1347 1255 ) 1348 1256 1349 1257 #define DEFINE_SMB3_OPEN_DONE_EVENT(name) \ ··· 1354 1260 __u32 tid, \ 1355 1261 __u64 sesid, \ 1356 1262 int create_options, \ 1357 - int desired_access), \ 1358 - TP_ARGS(xid, fid, tid, sesid, create_options, desired_access)) 1263 + int desired_access, \ 1264 + __u8 oplock), \ 1265 + TP_ARGS(xid, fid, tid, sesid, create_options, desired_access, oplock)) 1359 1266 1360 1267 DEFINE_SMB3_OPEN_DONE_EVENT(open_done); 1361 1268 DEFINE_SMB3_OPEN_DONE_EVENT(posix_mkdir_done); 1269 + 1270 + TRACE_EVENT(smb3_open_cached, 1271 + TP_PROTO(unsigned int xid, 1272 + __u32 tid, 1273 + __u64 sesid, 1274 + __u64 fid, 1275 + unsigned int oflags, 1276 + unsigned int cflags), 1277 + TP_ARGS(xid, tid, sesid, fid, oflags, cflags), 1278 + TP_STRUCT__entry( 1279 + __field(unsigned int, xid) 1280 + __field(__u32, tid) 1281 + __field(__u64, sesid) 1282 + __field(__u64, fid) 1283 + __field(unsigned int, oflags) 1284 + __field(unsigned int, cflags) 1285 + ), 1286 + TP_fast_assign( 1287 + __entry->xid = xid; 1288 + __entry->tid = tid; 1289 + __entry->sesid = sesid; 1290 + __entry->fid = fid; 1291 + __entry->oflags = oflags; 1292 + __entry->cflags = cflags; 1293 + ), 1294 + TP_printk("xid=%u sid=0x%llx tid=0x%x fid=0x%llx oflags=0x%x cflags=0x%x", 1295 + __entry->xid, __entry->sesid, __entry->tid, __entry->fid, 1296 + __entry->oflags, __entry->cflags) 1297 + ); 1298 + 1299 + TRACE_EVENT(smb3_close_cached, 1300 + TP_PROTO(__u32 tid, 1301 + __u64 sesid, 1302 + __u64 fid, 1303 + unsigned long delay_jiffies), 1304 + TP_ARGS(tid, sesid, fid, delay_jiffies), 1305 + TP_STRUCT__entry( 1306 + __field(__u32, tid) 1307 + __field(__u64, sesid) 1308 + __field(__u64, fid) 1309 + __field(unsigned long, delay_jiffies) 1310 + ), 1311 + TP_fast_assign( 1312 + __entry->tid = tid; 1313 + __entry->sesid = sesid; 1314 + __entry->fid = fid; 1315 + __entry->delay_jiffies = delay_jiffies; 1316 + ), 1317 + TP_printk("sid=0x%llx tid=0x%x fid=0x%llx delay_jiffies=%lu", 1318 + __entry->sesid, __entry->tid, __entry->fid, __entry->delay_jiffies) 1319 + ); 1362 1320 1363 1321 1364 1322 DECLARE_EVENT_CLASS(smb3_lease_done_class,

+1 -1

include/linux/dcache.h

··· 264 264 extern struct dentry * d_make_root(struct inode *); 265 265 266 266 extern void d_mark_tmpfile(struct file *, struct inode *); 267 - void d_mark_tmpfile_name(struct file *file, const struct qstr *name); 267 + int d_mark_tmpfile_name(struct file *file, const struct qstr *name); 268 268 extern void d_tmpfile(struct file *, struct inode *); 269 269 270 270 extern struct dentry *d_find_alias(struct inode *);

Configure Feed

Configure Feed