1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/fs.h>
23#include <linux/string.h>
24#include <linux/ctype.h>
25#include <linux/module.h>
26#include <linux/proc_fs.h>
27#include <asm/uaccess.h>
28#include "cifspdu.h"
29#include "cifsglob.h"
30#include "cifsproto.h"
31#include "cifs_debug.h"
32#include "cifsfs.h"
33
34void
35cifs_dump_mem(char *label, void *data, int length)
36{
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,
39 data, length, true);
40}
41
42#ifdef CONFIG_CIFS_DEBUG
43void cifs_vfs_err(const char *fmt, ...)
44{
45 struct va_format vaf;
46 va_list args;
47
48 va_start(args, fmt);
49
50 vaf.fmt = fmt;
51 vaf.va = &args;
52
53 pr_err_ratelimited("CIFS VFS: %pV", &vaf);
54
55 va_end(args);
56}
57#endif
58
59void cifs_dump_detail(void *buf)
60{
61#ifdef CONFIG_CIFS_DEBUG2
62 struct smb_hdr *smb = (struct smb_hdr *)buf;
63
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
69}
70
71void cifs_dump_mids(struct TCP_Server_Info *server)
72{
73#ifdef CONFIG_CIFS_DEBUG2
74 struct list_head *tmp;
75 struct mid_q_entry *mid_entry;
76
77 if (server == NULL)
78 return;
79
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",
85 mid_entry->mid_state,
86 le16_to_cpu(mid_entry->command),
87 mid_entry->pid,
88 mid_entry->callback_data,
89 mid_entry->mid);
90#ifdef CONFIG_CIFS_STATS2
91 cifs_dbg(VFS, "IsLarge: %d buf: %p time rcv: %ld now: %ld\n",
92 mid_entry->large_buf,
93 mid_entry->resp_buf,
94 mid_entry->when_received,
95 jiffies);
96#endif
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);
103 }
104 }
105 spin_unlock(&GlobalMid_Lock);
106#endif
107}
108
109#ifdef CONFIG_PROC_FS
110static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
111{
112 struct list_head *tmp1, *tmp2, *tmp3;
113 struct mid_q_entry *mid_entry;
114 struct TCP_Server_Info *server;
115 struct cifs_ses *ses;
116 struct cifs_tcon *tcon;
117 int i, j;
118 __u32 dev_type;
119
120 seq_puts(m,
121 "Display Internal CIFS Data Structures for Debugging\n"
122 "---------------------------------------------------\n");
123 seq_printf(m, "CIFS Version %s\n", CIFS_VERSION);
124 seq_printf(m, "Features:");
125#ifdef CONFIG_CIFS_DFS_UPCALL
126 seq_printf(m, " dfs");
127#endif
128#ifdef CONFIG_CIFS_FSCACHE
129 seq_printf(m, " fscache");
130#endif
131#ifdef CONFIG_CIFS_WEAK_PW_HASH
132 seq_printf(m, " lanman");
133#endif
134#ifdef CONFIG_CIFS_POSIX
135 seq_printf(m, " posix");
136#endif
137#ifdef CONFIG_CIFS_UPCALL
138 seq_printf(m, " spnego");
139#endif
140#ifdef CONFIG_CIFS_XATTR
141 seq_printf(m, " xattr");
142#endif
143#ifdef CONFIG_CIFS_ACL
144 seq_printf(m, " acl");
145#endif
146 seq_putc(m, '\n');
147 seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid);
148 seq_printf(m, "Servers:");
149
150 i = 0;
151 spin_lock(&cifs_tcp_ses_lock);
152 list_for_each(tmp1, &cifs_tcp_ses_list) {
153 server = list_entry(tmp1, struct TCP_Server_Info,
154 tcp_ses_list);
155 seq_printf(m, "\nNumber of credits: %d", server->credits);
156 i++;
157 list_for_each(tmp2, &server->smb_ses_list) {
158 ses = list_entry(tmp2, struct cifs_ses,
159 smb_ses_list);
160 if ((ses->serverDomain == NULL) ||
161 (ses->serverOS == NULL) ||
162 (ses->serverNOS == NULL)) {
163 seq_printf(m, "\n%d) entry for %s not fully "
164 "displayed\n\t", i, ses->serverName);
165 } else {
166 seq_printf(m,
167 "\n%d) Name: %s Domain: %s Uses: %d OS:"
168 " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB"
169 " session status: %d\t",
170 i, ses->serverName, ses->serverDomain,
171 ses->ses_count, ses->serverOS, ses->serverNOS,
172 ses->capabilities, ses->status);
173 }
174 seq_printf(m, "TCP status: %d\n\tLocal Users To "
175 "Server: %d SecMode: 0x%x Req On Wire: %d",
176 server->tcpStatus, server->srv_count,
177 server->sec_mode, in_flight(server));
178
179#ifdef CONFIG_CIFS_STATS2
180 seq_printf(m, " In Send: %d In MaxReq Wait: %d",
181 atomic_read(&server->in_send),
182 atomic_read(&server->num_waiters));
183#endif
184
185 seq_puts(m, "\n\tShares:");
186 j = 0;
187 list_for_each(tmp3, &ses->tcon_list) {
188 tcon = list_entry(tmp3, struct cifs_tcon,
189 tcon_list);
190 ++j;
191 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
192 seq_printf(m, "\n\t%d) %s Mounts: %d ", j,
193 tcon->treeName, tcon->tc_count);
194 if (tcon->nativeFileSystem) {
195 seq_printf(m, "Type: %s ",
196 tcon->nativeFileSystem);
197 }
198 seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x"
199 "\n\tPathComponentMax: %d Status: %d",
200 le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
201 le32_to_cpu(tcon->fsAttrInfo.Attributes),
202 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
203 tcon->tidStatus);
204 if (dev_type == FILE_DEVICE_DISK)
205 seq_puts(m, " type: DISK ");
206 else if (dev_type == FILE_DEVICE_CD_ROM)
207 seq_puts(m, " type: CDROM ");
208 else
209 seq_printf(m, " type: %d ", dev_type);
210 if (server->ops->dump_share_caps)
211 server->ops->dump_share_caps(m, tcon);
212
213 if (tcon->need_reconnect)
214 seq_puts(m, "\tDISCONNECTED ");
215 seq_putc(m, '\n');
216 }
217
218 seq_puts(m, "\n\tMIDs:\n");
219
220 spin_lock(&GlobalMid_Lock);
221 list_for_each(tmp3, &server->pending_mid_q) {
222 mid_entry = list_entry(tmp3, struct mid_q_entry,
223 qhead);
224 seq_printf(m, "\tState: %d com: %d pid:"
225 " %d cbdata: %p mid %llu\n",
226 mid_entry->mid_state,
227 le16_to_cpu(mid_entry->command),
228 mid_entry->pid,
229 mid_entry->callback_data,
230 mid_entry->mid);
231 }
232 spin_unlock(&GlobalMid_Lock);
233 }
234 }
235 spin_unlock(&cifs_tcp_ses_lock);
236 seq_putc(m, '\n');
237
238
239 return 0;
240}
241
242static int cifs_debug_data_proc_open(struct inode *inode, struct file *file)
243{
244 return single_open(file, cifs_debug_data_proc_show, NULL);
245}
246
247static const struct file_operations cifs_debug_data_proc_fops = {
248 .open = cifs_debug_data_proc_open,
249 .read = seq_read,
250 .llseek = seq_lseek,
251 .release = single_release,
252};
253
254#ifdef CONFIG_CIFS_STATS
255static ssize_t cifs_stats_proc_write(struct file *file,
256 const char __user *buffer, size_t count, loff_t *ppos)
257{
258 bool bv;
259 int rc;
260 struct list_head *tmp1, *tmp2, *tmp3;
261 struct TCP_Server_Info *server;
262 struct cifs_ses *ses;
263 struct cifs_tcon *tcon;
264
265 rc = kstrtobool_from_user(buffer, count, &bv);
266 if (rc == 0) {
267#ifdef CONFIG_CIFS_STATS2
268 atomic_set(&totBufAllocCount, 0);
269 atomic_set(&totSmBufAllocCount, 0);
270#endif
271 spin_lock(&cifs_tcp_ses_lock);
272 list_for_each(tmp1, &cifs_tcp_ses_list) {
273 server = list_entry(tmp1, struct TCP_Server_Info,
274 tcp_ses_list);
275 list_for_each(tmp2, &server->smb_ses_list) {
276 ses = list_entry(tmp2, struct cifs_ses,
277 smb_ses_list);
278 list_for_each(tmp3, &ses->tcon_list) {
279 tcon = list_entry(tmp3,
280 struct cifs_tcon,
281 tcon_list);
282 atomic_set(&tcon->num_smbs_sent, 0);
283 if (server->ops->clear_stats)
284 server->ops->clear_stats(tcon);
285 }
286 }
287 }
288 spin_unlock(&cifs_tcp_ses_lock);
289 } else {
290 return rc;
291 }
292
293 return count;
294}
295
296static int cifs_stats_proc_show(struct seq_file *m, void *v)
297{
298 int i;
299 struct list_head *tmp1, *tmp2, *tmp3;
300 struct TCP_Server_Info *server;
301 struct cifs_ses *ses;
302 struct cifs_tcon *tcon;
303
304 seq_printf(m,
305 "Resources in use\nCIFS Session: %d\n",
306 sesInfoAllocCount.counter);
307 seq_printf(m, "Share (unique mount targets): %d\n",
308 tconInfoAllocCount.counter);
309 seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
310 bufAllocCount.counter,
311 cifs_min_rcv + tcpSesAllocCount.counter);
312 seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
313 smBufAllocCount.counter, cifs_min_small);
314#ifdef CONFIG_CIFS_STATS2
315 seq_printf(m, "Total Large %d Small %d Allocations\n",
316 atomic_read(&totBufAllocCount),
317 atomic_read(&totSmBufAllocCount));
318#endif
319
320 seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount));
321 seq_printf(m,
322 "\n%d session %d share reconnects\n",
323 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
324
325 seq_printf(m,
326 "Total vfs operations: %d maximum at one time: %d\n",
327 GlobalCurrentXid, GlobalMaxActiveXid);
328
329 i = 0;
330 spin_lock(&cifs_tcp_ses_lock);
331 list_for_each(tmp1, &cifs_tcp_ses_list) {
332 server = list_entry(tmp1, struct TCP_Server_Info,
333 tcp_ses_list);
334 list_for_each(tmp2, &server->smb_ses_list) {
335 ses = list_entry(tmp2, struct cifs_ses,
336 smb_ses_list);
337 list_for_each(tmp3, &ses->tcon_list) {
338 tcon = list_entry(tmp3,
339 struct cifs_tcon,
340 tcon_list);
341 i++;
342 seq_printf(m, "\n%d) %s", i, tcon->treeName);
343 if (tcon->need_reconnect)
344 seq_puts(m, "\tDISCONNECTED ");
345 seq_printf(m, "\nSMBs: %d",
346 atomic_read(&tcon->num_smbs_sent));
347 if (server->ops->print_stats)
348 server->ops->print_stats(m, tcon);
349 }
350 }
351 }
352 spin_unlock(&cifs_tcp_ses_lock);
353
354 seq_putc(m, '\n');
355 return 0;
356}
357
358static int cifs_stats_proc_open(struct inode *inode, struct file *file)
359{
360 return single_open(file, cifs_stats_proc_show, NULL);
361}
362
363static const struct file_operations cifs_stats_proc_fops = {
364 .open = cifs_stats_proc_open,
365 .read = seq_read,
366 .llseek = seq_lseek,
367 .release = single_release,
368 .write = cifs_stats_proc_write,
369};
370#endif
371
372static struct proc_dir_entry *proc_fs_cifs;
373static const struct file_operations cifsFYI_proc_fops;
374static const struct file_operations cifs_lookup_cache_proc_fops;
375static const struct file_operations traceSMB_proc_fops;
376static const struct file_operations cifs_security_flags_proc_fops;
377static const struct file_operations cifs_linux_ext_proc_fops;
378
379void
380cifs_proc_init(void)
381{
382 proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
383 if (proc_fs_cifs == NULL)
384 return;
385
386 proc_create("DebugData", 0, proc_fs_cifs, &cifs_debug_data_proc_fops);
387
388#ifdef CONFIG_CIFS_STATS
389 proc_create("Stats", 0, proc_fs_cifs, &cifs_stats_proc_fops);
390#endif
391 proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
392 proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
393 proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
394 &cifs_linux_ext_proc_fops);
395 proc_create("SecurityFlags", 0, proc_fs_cifs,
396 &cifs_security_flags_proc_fops);
397 proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
398 &cifs_lookup_cache_proc_fops);
399}
400
401void
402cifs_proc_clean(void)
403{
404 if (proc_fs_cifs == NULL)
405 return;
406
407 remove_proc_entry("DebugData", proc_fs_cifs);
408 remove_proc_entry("cifsFYI", proc_fs_cifs);
409 remove_proc_entry("traceSMB", proc_fs_cifs);
410#ifdef CONFIG_CIFS_STATS
411 remove_proc_entry("Stats", proc_fs_cifs);
412#endif
413 remove_proc_entry("SecurityFlags", proc_fs_cifs);
414 remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
415 remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
416 remove_proc_entry("fs/cifs", NULL);
417}
418
419static int cifsFYI_proc_show(struct seq_file *m, void *v)
420{
421 seq_printf(m, "%d\n", cifsFYI);
422 return 0;
423}
424
425static int cifsFYI_proc_open(struct inode *inode, struct file *file)
426{
427 return single_open(file, cifsFYI_proc_show, NULL);
428}
429
430static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
431 size_t count, loff_t *ppos)
432{
433 char c[2] = { '\0' };
434 bool bv;
435 int rc;
436
437 rc = get_user(c[0], buffer);
438 if (rc)
439 return rc;
440 if (strtobool(c, &bv) == 0)
441 cifsFYI = bv;
442 else if ((c[0] > '1') && (c[0] <= '9'))
443 cifsFYI = (int) (c[0] - '0');
444
445 return count;
446}
447
448static const struct file_operations cifsFYI_proc_fops = {
449 .open = cifsFYI_proc_open,
450 .read = seq_read,
451 .llseek = seq_lseek,
452 .release = single_release,
453 .write = cifsFYI_proc_write,
454};
455
456static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
457{
458 seq_printf(m, "%d\n", linuxExtEnabled);
459 return 0;
460}
461
462static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
463{
464 return single_open(file, cifs_linux_ext_proc_show, NULL);
465}
466
467static ssize_t cifs_linux_ext_proc_write(struct file *file,
468 const char __user *buffer, size_t count, loff_t *ppos)
469{
470 int rc;
471
472 rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled);
473 if (rc)
474 return rc;
475
476 return count;
477}
478
479static const struct file_operations cifs_linux_ext_proc_fops = {
480 .open = cifs_linux_ext_proc_open,
481 .read = seq_read,
482 .llseek = seq_lseek,
483 .release = single_release,
484 .write = cifs_linux_ext_proc_write,
485};
486
487static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
488{
489 seq_printf(m, "%d\n", lookupCacheEnabled);
490 return 0;
491}
492
493static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
494{
495 return single_open(file, cifs_lookup_cache_proc_show, NULL);
496}
497
498static ssize_t cifs_lookup_cache_proc_write(struct file *file,
499 const char __user *buffer, size_t count, loff_t *ppos)
500{
501 int rc;
502
503 rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled);
504 if (rc)
505 return rc;
506
507 return count;
508}
509
510static const struct file_operations cifs_lookup_cache_proc_fops = {
511 .open = cifs_lookup_cache_proc_open,
512 .read = seq_read,
513 .llseek = seq_lseek,
514 .release = single_release,
515 .write = cifs_lookup_cache_proc_write,
516};
517
518static int traceSMB_proc_show(struct seq_file *m, void *v)
519{
520 seq_printf(m, "%d\n", traceSMB);
521 return 0;
522}
523
524static int traceSMB_proc_open(struct inode *inode, struct file *file)
525{
526 return single_open(file, traceSMB_proc_show, NULL);
527}
528
529static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
530 size_t count, loff_t *ppos)
531{
532 int rc;
533
534 rc = kstrtobool_from_user(buffer, count, &traceSMB);
535 if (rc)
536 return rc;
537
538 return count;
539}
540
541static const struct file_operations traceSMB_proc_fops = {
542 .open = traceSMB_proc_open,
543 .read = seq_read,
544 .llseek = seq_lseek,
545 .release = single_release,
546 .write = traceSMB_proc_write,
547};
548
549static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
550{
551 seq_printf(m, "0x%x\n", global_secflags);
552 return 0;
553}
554
555static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
556{
557 return single_open(file, cifs_security_flags_proc_show, NULL);
558}
559
560
561
562
563
564
565static void
566cifs_security_flags_handle_must_flags(unsigned int *flags)
567{
568 unsigned int signflags = *flags & CIFSSEC_MUST_SIGN;
569
570 if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
571 *flags = CIFSSEC_MUST_KRB5;
572 else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
573 *flags = CIFSSEC_MUST_NTLMSSP;
574 else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
575 *flags = CIFSSEC_MUST_NTLMV2;
576 else if ((*flags & CIFSSEC_MUST_NTLM) == CIFSSEC_MUST_NTLM)
577 *flags = CIFSSEC_MUST_NTLM;
578 else if (CIFSSEC_MUST_LANMAN &&
579 (*flags & CIFSSEC_MUST_LANMAN) == CIFSSEC_MUST_LANMAN)
580 *flags = CIFSSEC_MUST_LANMAN;
581 else if (CIFSSEC_MUST_PLNTXT &&
582 (*flags & CIFSSEC_MUST_PLNTXT) == CIFSSEC_MUST_PLNTXT)
583 *flags = CIFSSEC_MUST_PLNTXT;
584
585 *flags |= signflags;
586}
587
588static ssize_t cifs_security_flags_proc_write(struct file *file,
589 const char __user *buffer, size_t count, loff_t *ppos)
590{
591 int rc;
592 unsigned int flags;
593 char flags_string[12];
594 bool bv;
595
596 if ((count < 1) || (count > 11))
597 return -EINVAL;
598
599 memset(flags_string, 0, 12);
600
601 if (copy_from_user(flags_string, buffer, count))
602 return -EFAULT;
603
604 if (count < 3) {
605
606 if (strtobool(flags_string, &bv) == 0) {
607 global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF;
608 return count;
609 } else if (!isdigit(flags_string[0])) {
610 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
611 flags_string);
612 return -EINVAL;
613 }
614 }
615
616
617 rc = kstrtouint(flags_string, 0, &flags);
618 if (rc) {
619 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
620 flags_string);
621 return rc;
622 }
623
624 cifs_dbg(FYI, "sec flags 0x%x\n", flags);
625
626 if (flags == 0) {
627 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string);
628 return -EINVAL;
629 }
630
631 if (flags & ~CIFSSEC_MASK) {
632 cifs_dbg(VFS, "Unsupported security flags: 0x%x\n",
633 flags & ~CIFSSEC_MASK);
634 return -EINVAL;
635 }
636
637 cifs_security_flags_handle_must_flags(&flags);
638
639
640 global_secflags = flags;
641 if (global_secflags & CIFSSEC_MUST_SIGN) {
642
643 global_secflags |= CIFSSEC_MAY_SIGN;
644 cifs_dbg(FYI, "packet signing now required\n");
645 } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) {
646 cifs_dbg(FYI, "packet signing disabled\n");
647 }
648
649 return count;
650}
651
652static const struct file_operations cifs_security_flags_proc_fops = {
653 .open = cifs_security_flags_proc_open,
654 .read = seq_read,
655 .llseek = seq_lseek,
656 .release = single_release,
657 .write = cifs_security_flags_proc_write,
658};
659#else
660inline void cifs_proc_init(void)
661{
662}
663
664inline void cifs_proc_clean(void)
665{
666}
667#endif
668
