4 * Copyright (C) International Business Machines Corp., 2000,2005
6 * Modified by Steve French (sfrench@us.ibm.com)
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16 * the GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/string.h>
24 #include <linux/ctype.h>
25 #include <linux/module.h>
26 #include <linux/proc_fs.h>
27 #include <linux/uaccess.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
35 cifs_dump_mem(char *label
, void *data
, int length
)
37 pr_debug("%s: dump of %d bytes of data at 0x%p\n", label
, length
, data
);
38 print_hex_dump(KERN_DEBUG
, "", DUMP_PREFIX_OFFSET
, 16, 4,
42 #ifdef CONFIG_CIFS_DEBUG
43 void cifs_vfs_err(const char *fmt
, ...)
53 pr_err_ratelimited("CIFS VFS: %pV", &vaf
);
59 void cifs_dump_detail(void *buf
)
61 #ifdef CONFIG_CIFS_DEBUG2
62 struct smb_hdr
*smb
= (struct smb_hdr
*)buf
;
64 cifs_dbg(VFS
, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d\n",
65 smb
->Command
, smb
->Status
.CifsError
,
66 smb
->Flags
, smb
->Flags2
, smb
->Mid
, smb
->Pid
);
67 cifs_dbg(VFS
, "smb buf %p len %u\n", smb
, smbCalcSize(smb
));
68 #endif /* CONFIG_CIFS_DEBUG2 */
71 void cifs_dump_mids(struct TCP_Server_Info
*server
)
73 #ifdef CONFIG_CIFS_DEBUG2
74 struct list_head
*tmp
;
75 struct mid_q_entry
*mid_entry
;
80 cifs_dbg(VFS
, "Dump pending requests:\n");
81 spin_lock(&GlobalMid_Lock
);
82 list_for_each(tmp
, &server
->pending_mid_q
) {
83 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
84 cifs_dbg(VFS
, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu\n",
86 le16_to_cpu(mid_entry
->command
),
88 mid_entry
->callback_data
,
90 #ifdef CONFIG_CIFS_STATS2
91 cifs_dbg(VFS
, "IsLarge: %d buf: %p time rcv: %ld now: %ld\n",
94 mid_entry
->when_received
,
97 cifs_dbg(VFS
, "IsMult: %d IsEnd: %d\n",
98 mid_entry
->multiRsp
, mid_entry
->multiEnd
);
99 if (mid_entry
->resp_buf
) {
100 cifs_dump_detail(mid_entry
->resp_buf
);
101 cifs_dump_mem("existing buf: ",
102 mid_entry
->resp_buf
, 62);
105 spin_unlock(&GlobalMid_Lock
);
106 #endif /* CONFIG_CIFS_DEBUG2 */
109 #ifdef CONFIG_PROC_FS
110 static void cifs_debug_tcon(struct seq_file
*m
, struct cifs_tcon
*tcon
)
112 __u32 dev_type
= le32_to_cpu(tcon
->fsDevInfo
.DeviceType
);
114 seq_printf(m
, "%s Mounts: %d ", tcon
->treeName
, tcon
->tc_count
);
115 if (tcon
->nativeFileSystem
)
116 seq_printf(m
, "Type: %s ", tcon
->nativeFileSystem
);
117 seq_printf(m
, "DevInfo: 0x%x Attributes: 0x%x\n\tPathComponentMax: %d Status: %d",
118 le32_to_cpu(tcon
->fsDevInfo
.DeviceCharacteristics
),
119 le32_to_cpu(tcon
->fsAttrInfo
.Attributes
),
120 le32_to_cpu(tcon
->fsAttrInfo
.MaxPathNameComponentLength
),
122 if (dev_type
== FILE_DEVICE_DISK
)
123 seq_puts(m
, " type: DISK ");
124 else if (dev_type
== FILE_DEVICE_CD_ROM
)
125 seq_puts(m
, " type: CDROM ");
127 seq_printf(m
, " type: %d ", dev_type
);
128 if (tcon
->ses
->server
->ops
->dump_share_caps
)
129 tcon
->ses
->server
->ops
->dump_share_caps(m
, tcon
);
131 if (tcon
->need_reconnect
)
132 seq_puts(m
, "\tDISCONNECTED ");
136 static int cifs_debug_data_proc_show(struct seq_file
*m
, void *v
)
138 struct list_head
*tmp1
, *tmp2
, *tmp3
;
139 struct mid_q_entry
*mid_entry
;
140 struct TCP_Server_Info
*server
;
141 struct cifs_ses
*ses
;
142 struct cifs_tcon
*tcon
;
146 "Display Internal CIFS Data Structures for Debugging\n"
147 "---------------------------------------------------\n");
148 seq_printf(m
, "CIFS Version %s\n", CIFS_VERSION
);
149 seq_printf(m
, "Features:");
150 #ifdef CONFIG_CIFS_DFS_UPCALL
151 seq_printf(m
, " dfs");
153 #ifdef CONFIG_CIFS_FSCACHE
154 seq_printf(m
, " fscache");
156 #ifdef CONFIG_CIFS_WEAK_PW_HASH
157 seq_printf(m
, " lanman");
159 #ifdef CONFIG_CIFS_POSIX
160 seq_printf(m
, " posix");
162 #ifdef CONFIG_CIFS_UPCALL
163 seq_printf(m
, " spnego");
165 #ifdef CONFIG_CIFS_XATTR
166 seq_printf(m
, " xattr");
168 #ifdef CONFIG_CIFS_ACL
169 seq_printf(m
, " acl");
172 seq_printf(m
, "Active VFS Requests: %d\n", GlobalTotalActiveXid
);
173 seq_printf(m
, "Servers:");
176 spin_lock(&cifs_tcp_ses_lock
);
177 list_for_each(tmp1
, &cifs_tcp_ses_list
) {
178 server
= list_entry(tmp1
, struct TCP_Server_Info
,
180 seq_printf(m
, "\nNumber of credits: %d", server
->credits
);
182 list_for_each(tmp2
, &server
->smb_ses_list
) {
183 ses
= list_entry(tmp2
, struct cifs_ses
,
185 if ((ses
->serverDomain
== NULL
) ||
186 (ses
->serverOS
== NULL
) ||
187 (ses
->serverNOS
== NULL
)) {
188 seq_printf(m
, "\n%d) Name: %s Uses: %d Capability: 0x%x\tSession Status: %d\t",
189 i
, ses
->serverName
, ses
->ses_count
,
190 ses
->capabilities
, ses
->status
);
191 if (ses
->session_flags
& SMB2_SESSION_FLAG_IS_GUEST
)
192 seq_printf(m
, "Guest\t");
193 else if (ses
->session_flags
& SMB2_SESSION_FLAG_IS_NULL
)
194 seq_printf(m
, "Anonymous\t");
197 "\n%d) Name: %s Domain: %s Uses: %d OS:"
198 " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB"
199 " session status: %d\t",
200 i
, ses
->serverName
, ses
->serverDomain
,
201 ses
->ses_count
, ses
->serverOS
, ses
->serverNOS
,
202 ses
->capabilities
, ses
->status
);
204 seq_printf(m
, "TCP status: %d\n\tLocal Users To "
205 "Server: %d SecMode: 0x%x Req On Wire: %d",
206 server
->tcpStatus
, server
->srv_count
,
207 server
->sec_mode
, in_flight(server
));
209 #ifdef CONFIG_CIFS_STATS2
210 seq_printf(m
, " In Send: %d In MaxReq Wait: %d",
211 atomic_read(&server
->in_send
),
212 atomic_read(&server
->num_waiters
));
215 seq_puts(m
, "\n\tShares:");
218 seq_printf(m
, "\n\t%d) IPC: ", j
);
220 cifs_debug_tcon(m
, ses
->tcon_ipc
);
222 seq_puts(m
, "none\n");
224 list_for_each(tmp3
, &ses
->tcon_list
) {
225 tcon
= list_entry(tmp3
, struct cifs_tcon
,
228 seq_printf(m
, "\n\t%d) ", j
);
229 cifs_debug_tcon(m
, tcon
);
232 seq_puts(m
, "\n\tMIDs:\n");
234 spin_lock(&GlobalMid_Lock
);
235 list_for_each(tmp3
, &server
->pending_mid_q
) {
236 mid_entry
= list_entry(tmp3
, struct mid_q_entry
,
238 seq_printf(m
, "\tState: %d com: %d pid:"
239 " %d cbdata: %p mid %llu\n",
240 mid_entry
->mid_state
,
241 le16_to_cpu(mid_entry
->command
),
243 mid_entry
->callback_data
,
246 spin_unlock(&GlobalMid_Lock
);
249 spin_unlock(&cifs_tcp_ses_lock
);
252 /* BB add code to dump additional info such as TCP session info now */
256 static int cifs_debug_data_proc_open(struct inode
*inode
, struct file
*file
)
258 return single_open(file
, cifs_debug_data_proc_show
, NULL
);
261 static const struct file_operations cifs_debug_data_proc_fops
= {
262 .open
= cifs_debug_data_proc_open
,
265 .release
= single_release
,
268 #ifdef CONFIG_CIFS_STATS
269 static ssize_t
cifs_stats_proc_write(struct file
*file
,
270 const char __user
*buffer
, size_t count
, loff_t
*ppos
)
274 struct list_head
*tmp1
, *tmp2
, *tmp3
;
275 struct TCP_Server_Info
*server
;
276 struct cifs_ses
*ses
;
277 struct cifs_tcon
*tcon
;
279 rc
= kstrtobool_from_user(buffer
, count
, &bv
);
281 #ifdef CONFIG_CIFS_STATS2
282 atomic_set(&totBufAllocCount
, 0);
283 atomic_set(&totSmBufAllocCount
, 0);
284 #endif /* CONFIG_CIFS_STATS2 */
285 spin_lock(&cifs_tcp_ses_lock
);
286 list_for_each(tmp1
, &cifs_tcp_ses_list
) {
287 server
= list_entry(tmp1
, struct TCP_Server_Info
,
289 list_for_each(tmp2
, &server
->smb_ses_list
) {
290 ses
= list_entry(tmp2
, struct cifs_ses
,
292 list_for_each(tmp3
, &ses
->tcon_list
) {
293 tcon
= list_entry(tmp3
,
296 atomic_set(&tcon
->num_smbs_sent
, 0);
297 if (server
->ops
->clear_stats
)
298 server
->ops
->clear_stats(tcon
);
302 spin_unlock(&cifs_tcp_ses_lock
);
310 static int cifs_stats_proc_show(struct seq_file
*m
, void *v
)
313 struct list_head
*tmp1
, *tmp2
, *tmp3
;
314 struct TCP_Server_Info
*server
;
315 struct cifs_ses
*ses
;
316 struct cifs_tcon
*tcon
;
319 "Resources in use\nCIFS Session: %d\n",
320 sesInfoAllocCount
.counter
);
321 seq_printf(m
, "Share (unique mount targets): %d\n",
322 tconInfoAllocCount
.counter
);
323 seq_printf(m
, "SMB Request/Response Buffer: %d Pool size: %d\n",
324 bufAllocCount
.counter
,
325 cifs_min_rcv
+ tcpSesAllocCount
.counter
);
326 seq_printf(m
, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
327 smBufAllocCount
.counter
, cifs_min_small
);
328 #ifdef CONFIG_CIFS_STATS2
329 seq_printf(m
, "Total Large %d Small %d Allocations\n",
330 atomic_read(&totBufAllocCount
),
331 atomic_read(&totSmBufAllocCount
));
332 #endif /* CONFIG_CIFS_STATS2 */
334 seq_printf(m
, "Operations (MIDs): %d\n", atomic_read(&midCount
));
336 "\n%d session %d share reconnects\n",
337 tcpSesReconnectCount
.counter
, tconInfoReconnectCount
.counter
);
340 "Total vfs operations: %d maximum at one time: %d\n",
341 GlobalCurrentXid
, GlobalMaxActiveXid
);
344 spin_lock(&cifs_tcp_ses_lock
);
345 list_for_each(tmp1
, &cifs_tcp_ses_list
) {
346 server
= list_entry(tmp1
, struct TCP_Server_Info
,
348 list_for_each(tmp2
, &server
->smb_ses_list
) {
349 ses
= list_entry(tmp2
, struct cifs_ses
,
351 list_for_each(tmp3
, &ses
->tcon_list
) {
352 tcon
= list_entry(tmp3
,
356 seq_printf(m
, "\n%d) %s", i
, tcon
->treeName
);
357 if (tcon
->need_reconnect
)
358 seq_puts(m
, "\tDISCONNECTED ");
359 seq_printf(m
, "\nSMBs: %d",
360 atomic_read(&tcon
->num_smbs_sent
));
361 if (server
->ops
->print_stats
)
362 server
->ops
->print_stats(m
, tcon
);
366 spin_unlock(&cifs_tcp_ses_lock
);
372 static int cifs_stats_proc_open(struct inode
*inode
, struct file
*file
)
374 return single_open(file
, cifs_stats_proc_show
, NULL
);
377 static const struct file_operations cifs_stats_proc_fops
= {
378 .open
= cifs_stats_proc_open
,
381 .release
= single_release
,
382 .write
= cifs_stats_proc_write
,
386 static struct proc_dir_entry
*proc_fs_cifs
;
387 static const struct file_operations cifsFYI_proc_fops
;
388 static const struct file_operations cifs_lookup_cache_proc_fops
;
389 static const struct file_operations traceSMB_proc_fops
;
390 static const struct file_operations cifs_security_flags_proc_fops
;
391 static const struct file_operations cifs_linux_ext_proc_fops
;
396 proc_fs_cifs
= proc_mkdir("fs/cifs", NULL
);
397 if (proc_fs_cifs
== NULL
)
400 proc_create("DebugData", 0, proc_fs_cifs
, &cifs_debug_data_proc_fops
);
402 #ifdef CONFIG_CIFS_STATS
403 proc_create("Stats", 0, proc_fs_cifs
, &cifs_stats_proc_fops
);
405 proc_create("cifsFYI", 0, proc_fs_cifs
, &cifsFYI_proc_fops
);
406 proc_create("traceSMB", 0, proc_fs_cifs
, &traceSMB_proc_fops
);
407 proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs
,
408 &cifs_linux_ext_proc_fops
);
409 proc_create("SecurityFlags", 0, proc_fs_cifs
,
410 &cifs_security_flags_proc_fops
);
411 proc_create("LookupCacheEnabled", 0, proc_fs_cifs
,
412 &cifs_lookup_cache_proc_fops
);
416 cifs_proc_clean(void)
418 if (proc_fs_cifs
== NULL
)
421 remove_proc_entry("DebugData", proc_fs_cifs
);
422 remove_proc_entry("cifsFYI", proc_fs_cifs
);
423 remove_proc_entry("traceSMB", proc_fs_cifs
);
424 #ifdef CONFIG_CIFS_STATS
425 remove_proc_entry("Stats", proc_fs_cifs
);
427 remove_proc_entry("SecurityFlags", proc_fs_cifs
);
428 remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs
);
429 remove_proc_entry("LookupCacheEnabled", proc_fs_cifs
);
430 remove_proc_entry("fs/cifs", NULL
);
433 static int cifsFYI_proc_show(struct seq_file
*m
, void *v
)
435 seq_printf(m
, "%d\n", cifsFYI
);
439 static int cifsFYI_proc_open(struct inode
*inode
, struct file
*file
)
441 return single_open(file
, cifsFYI_proc_show
, NULL
);
444 static ssize_t
cifsFYI_proc_write(struct file
*file
, const char __user
*buffer
,
445 size_t count
, loff_t
*ppos
)
447 char c
[2] = { '\0' };
451 rc
= get_user(c
[0], buffer
);
454 if (strtobool(c
, &bv
) == 0)
456 else if ((c
[0] > '1') && (c
[0] <= '9'))
457 cifsFYI
= (int) (c
[0] - '0'); /* see cifs_debug.h for meanings */
462 static const struct file_operations cifsFYI_proc_fops
= {
463 .open
= cifsFYI_proc_open
,
466 .release
= single_release
,
467 .write
= cifsFYI_proc_write
,
470 static int cifs_linux_ext_proc_show(struct seq_file
*m
, void *v
)
472 seq_printf(m
, "%d\n", linuxExtEnabled
);
476 static int cifs_linux_ext_proc_open(struct inode
*inode
, struct file
*file
)
478 return single_open(file
, cifs_linux_ext_proc_show
, NULL
);
481 static ssize_t
cifs_linux_ext_proc_write(struct file
*file
,
482 const char __user
*buffer
, size_t count
, loff_t
*ppos
)
486 rc
= kstrtobool_from_user(buffer
, count
, &linuxExtEnabled
);
493 static const struct file_operations cifs_linux_ext_proc_fops
= {
494 .open
= cifs_linux_ext_proc_open
,
497 .release
= single_release
,
498 .write
= cifs_linux_ext_proc_write
,
501 static int cifs_lookup_cache_proc_show(struct seq_file
*m
, void *v
)
503 seq_printf(m
, "%d\n", lookupCacheEnabled
);
507 static int cifs_lookup_cache_proc_open(struct inode
*inode
, struct file
*file
)
509 return single_open(file
, cifs_lookup_cache_proc_show
, NULL
);
512 static ssize_t
cifs_lookup_cache_proc_write(struct file
*file
,
513 const char __user
*buffer
, size_t count
, loff_t
*ppos
)
517 rc
= kstrtobool_from_user(buffer
, count
, &lookupCacheEnabled
);
524 static const struct file_operations cifs_lookup_cache_proc_fops
= {
525 .open
= cifs_lookup_cache_proc_open
,
528 .release
= single_release
,
529 .write
= cifs_lookup_cache_proc_write
,
532 static int traceSMB_proc_show(struct seq_file
*m
, void *v
)
534 seq_printf(m
, "%d\n", traceSMB
);
538 static int traceSMB_proc_open(struct inode
*inode
, struct file
*file
)
540 return single_open(file
, traceSMB_proc_show
, NULL
);
543 static ssize_t
traceSMB_proc_write(struct file
*file
, const char __user
*buffer
,
544 size_t count
, loff_t
*ppos
)
548 rc
= kstrtobool_from_user(buffer
, count
, &traceSMB
);
555 static const struct file_operations traceSMB_proc_fops
= {
556 .open
= traceSMB_proc_open
,
559 .release
= single_release
,
560 .write
= traceSMB_proc_write
,
563 static int cifs_security_flags_proc_show(struct seq_file
*m
, void *v
)
565 seq_printf(m
, "0x%x\n", global_secflags
);
569 static int cifs_security_flags_proc_open(struct inode
*inode
, struct file
*file
)
571 return single_open(file
, cifs_security_flags_proc_show
, NULL
);
575 * Ensure that if someone sets a MUST flag, that we disable all other MAY
576 * flags except for the ones corresponding to the given MUST flag. If there are
577 * multiple MUST flags, then try to prefer more secure ones.
580 cifs_security_flags_handle_must_flags(unsigned int *flags
)
582 unsigned int signflags
= *flags
& CIFSSEC_MUST_SIGN
;
584 if ((*flags
& CIFSSEC_MUST_KRB5
) == CIFSSEC_MUST_KRB5
)
585 *flags
= CIFSSEC_MUST_KRB5
;
586 else if ((*flags
& CIFSSEC_MUST_NTLMSSP
) == CIFSSEC_MUST_NTLMSSP
)
587 *flags
= CIFSSEC_MUST_NTLMSSP
;
588 else if ((*flags
& CIFSSEC_MUST_NTLMV2
) == CIFSSEC_MUST_NTLMV2
)
589 *flags
= CIFSSEC_MUST_NTLMV2
;
590 else if ((*flags
& CIFSSEC_MUST_NTLM
) == CIFSSEC_MUST_NTLM
)
591 *flags
= CIFSSEC_MUST_NTLM
;
592 else if (CIFSSEC_MUST_LANMAN
&&
593 (*flags
& CIFSSEC_MUST_LANMAN
) == CIFSSEC_MUST_LANMAN
)
594 *flags
= CIFSSEC_MUST_LANMAN
;
595 else if (CIFSSEC_MUST_PLNTXT
&&
596 (*flags
& CIFSSEC_MUST_PLNTXT
) == CIFSSEC_MUST_PLNTXT
)
597 *flags
= CIFSSEC_MUST_PLNTXT
;
602 static ssize_t
cifs_security_flags_proc_write(struct file
*file
,
603 const char __user
*buffer
, size_t count
, loff_t
*ppos
)
607 char flags_string
[12];
610 if ((count
< 1) || (count
> 11))
613 memset(flags_string
, 0, 12);
615 if (copy_from_user(flags_string
, buffer
, count
))
619 /* single char or single char followed by null */
620 if (strtobool(flags_string
, &bv
) == 0) {
621 global_secflags
= bv
? CIFSSEC_MAX
: CIFSSEC_DEF
;
623 } else if (!isdigit(flags_string
[0])) {
624 cifs_dbg(VFS
, "Invalid SecurityFlags: %s\n",
630 /* else we have a number */
631 rc
= kstrtouint(flags_string
, 0, &flags
);
633 cifs_dbg(VFS
, "Invalid SecurityFlags: %s\n",
638 cifs_dbg(FYI
, "sec flags 0x%x\n", flags
);
641 cifs_dbg(VFS
, "Invalid SecurityFlags: %s\n", flags_string
);
645 if (flags
& ~CIFSSEC_MASK
) {
646 cifs_dbg(VFS
, "Unsupported security flags: 0x%x\n",
647 flags
& ~CIFSSEC_MASK
);
651 cifs_security_flags_handle_must_flags(&flags
);
653 /* flags look ok - update the global security flags for cifs module */
654 global_secflags
= flags
;
655 if (global_secflags
& CIFSSEC_MUST_SIGN
) {
656 /* requiring signing implies signing is allowed */
657 global_secflags
|= CIFSSEC_MAY_SIGN
;
658 cifs_dbg(FYI
, "packet signing now required\n");
659 } else if ((global_secflags
& CIFSSEC_MAY_SIGN
) == 0) {
660 cifs_dbg(FYI
, "packet signing disabled\n");
662 /* BB should we turn on MAY flags for other MUST options? */
666 static const struct file_operations cifs_security_flags_proc_fops
= {
667 .open
= cifs_security_flags_proc_open
,
670 .release
= single_release
,
671 .write
= cifs_security_flags_proc_write
,
674 inline void cifs_proc_init(void)
678 inline void cifs_proc_clean(void)