?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / fs / cifs / cifs_debug.c
blob0cf2b223e49078d4636e4f42a22e0c341be40905
1 /*
2 * fs/cifs_debug.c
3 *
4 * Copyright (C) International Business Machines Corp., 2000,2003
5 *
6 * Modified by Steve French (sfrench@us.ibm.com)
7 *
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.
12 *
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.
17 *
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
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
33 void
34 cifs_dump_mem(char *label, void *data, int length)
35 {
36 int i, j;
37 int *intptr = data;
38 char *charptr = data;
39 char buf[10], line[80];
40
41 printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n\n",
42 label, length, data);
43 for (i = 0; i < length; i += 16) {
44 line[0] = 0;
45 for (j = 0; (j < 4) && (i + j * 4 < length); j++) {
46 sprintf(buf, " %08x", intptr[i / 4 + j]);
47 strcat(line, buf);
48 }
49 buf[0] = ' ';
50 buf[2] = 0;
51 for (j = 0; (j < 16) && (i + j < length); j++) {
52 buf[1] = isprint(charptr[i + j]) ? charptr[i + j] : '.';
53 strcat(line, buf);
54 }
55 printk(KERN_DEBUG "%s\n", line);
56 }
57 }
58
59 #ifdef CONFIG_PROC_FS
60 int
61 cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
62 int count, int *eof, void *data)
63 {
64 struct list_head *tmp;
65 struct list_head *tmp1;
66 struct mid_q_entry * mid_entry;
67 struct cifsSesInfo *ses;
68 struct cifsTconInfo *tcon;
69 int i;
70 int length = 0;
71 char * original_buf = buf;
72
73 *beginBuffer = buf + offset;
74
75
76 length =
77 sprintf(buf,
78 "Display Internal CIFS Data Structures for Debugging\n"
79 "---------------------------------------------------\n");
80 buf += length;
81
82 length = sprintf(buf, "Servers:\n");
83 buf += length;
84
85 i = 0;
86 read_lock(&GlobalSMBSeslock);
87 list_for_each(tmp, &GlobalSMBSessionList) {
88 i++;
89 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
90 length =
91 sprintf(buf,
92 "\n%d) Name: %s Domain: %s Mounts: %d ServerOS: %s \n\tServerNOS: %s\tCapabilities: 0x%x\n\tSMB session status: %d\tTCP status: %d",
93 i, ses->serverName, ses->serverDomain, atomic_read(&ses->inUse),
94 ses->serverOS, ses->serverNOS, ses->capabilities,ses->status,ses->server->tcpStatus);
95 buf += length;
96 if(ses->server) {
97 buf += sprintf(buf, "\n\tLocal Users To Server: %d SecMode: 0x%x Req Active: %d",
98 atomic_read(&ses->server->socketUseCount),
99 ses->server->secMode,
100 atomic_read(&ses->server->inFlight));
101
102 length = sprintf(buf, "\nMIDs: \n");
103 buf += length;
104
105 spin_lock(&GlobalMid_Lock);
106 list_for_each(tmp1, &ses->server->pending_mid_q) {
107 mid_entry = list_entry(tmp1, struct
108 mid_q_entry,
109 qhead);
110 if(mid_entry) {
111 length = sprintf(buf,"State: %d com: %d pid: %d tsk: %p mid %d\n",mid_entry->midState,mid_entry->command,mid_entry->pid,mid_entry->tsk,mid_entry->mid);
112 buf += length;
113 }
114 }
115 spin_unlock(&GlobalMid_Lock);
116 }
117
118 }
119 read_unlock(&GlobalSMBSeslock);
120 sprintf(buf, "\n");
121 buf++;
122
123 length = sprintf(buf, "\nShares:\n");
124 buf += length;
125
126 i = 0;
127 read_lock(&GlobalSMBSeslock);
128 list_for_each(tmp, &GlobalTreeConnectionList) {
129 __u32 dev_type;
130 i++;
131 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
132 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
133 length =
134 sprintf(buf,
135 "\n%d) %s Uses: %d Type: %s Characteristics: 0x%x Attributes: 0x%x\nPathComponentMax: %d Status: %d",
136 i, tcon->treeName,
137 atomic_read(&tcon->useCount),
138 tcon->nativeFileSystem,
139 le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
140 le32_to_cpu(tcon->fsAttrInfo.Attributes),
141 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
142 tcon->tidStatus);
143 buf += length;
144 if (dev_type == FILE_DEVICE_DISK)
145 length = sprintf(buf, " type: DISK ");
146 else if (dev_type == FILE_DEVICE_CD_ROM)
147 length = sprintf(buf, " type: CDROM ");
148 else
149 length =
150 sprintf(buf, " type: %d ", dev_type);
151 buf += length;
152 if(tcon->tidStatus == CifsNeedReconnect) {
153 buf += sprintf(buf, "\tDISCONNECTED ");
154 length += 14;
155 }
156 }
157 read_unlock(&GlobalSMBSeslock);
158
159 length = sprintf(buf, "\n");
160 buf += length;
161
162 /* BB add code to dump additional info such as TCP session info now */
163 /* Now calculate total size of returned data */
164 length = buf - original_buf;
165
166 if(offset + count >= length)
167 *eof = 1;
168 if(length < offset) {
169 *eof = 1;
170 return 0;
171 } else {
172 length = length - offset;
173 }
174 if (length > count)
175 length = count;
176
177 return length;
178 }
179
180 #ifdef CONFIG_CIFS_STATS
181 int
182 cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
183 int count, int *eof, void *data)
184 {
185 int item_length,i,length;
186 struct list_head *tmp;
187 struct cifsTconInfo *tcon;
188
189 *beginBuffer = buf + offset;
190
191 length = sprintf(buf,
192 "Resources in use\nCIFS Session: %d\n",
193 sesInfoAllocCount.counter);
194 buf += length;
195 item_length =
196 sprintf(buf,"Share (unique mount targets): %d\n",
197 tconInfoAllocCount.counter);
198 length += item_length;
199 buf += item_length;
200 item_length =
201 sprintf(buf,"SMB Request/Response Buffer: %d\n",
202 bufAllocCount.counter);
203 length += item_length;
204 buf += item_length;
205 item_length =
206 sprintf(buf,"Operations (MIDs): %d\n",
207 midCount.counter);
208 length += item_length;
209 buf += item_length;
210 item_length = sprintf(buf,
211 "\n%d session %d share reconnects\n",
212 tcpSesReconnectCount.counter,tconInfoReconnectCount.counter);
213 length += item_length;
214 buf += item_length;
215
216 item_length = sprintf(buf,
217 "Total vfs operations: %d maximum at one time: %d\n",
218 GlobalCurrentXid,GlobalMaxActiveXid);
219 length += item_length;
220 buf += item_length;
221
222 i = 0;
223 read_lock(&GlobalSMBSeslock);
224 list_for_each(tmp, &GlobalTreeConnectionList) {
225 i++;
226 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
227 item_length = sprintf(buf,"\n%d) %s",i, tcon->treeName);
228 buf += item_length;
229 length += item_length;
230 if(tcon->tidStatus == CifsNeedReconnect) {
231 buf += sprintf(buf, "\tDISCONNECTED ");
232 length += 14;
233 }
234 item_length = sprintf(buf,"\nSMBs: %d Oplock Breaks: %d",
235 atomic_read(&tcon->num_smbs_sent),
236 atomic_read(&tcon->num_oplock_brks));
237 buf += item_length;
238 length += item_length;
239 item_length = sprintf(buf,"\nReads: %d Bytes %lld",
240 atomic_read(&tcon->num_reads),
241 (long long)(tcon->bytes_read));
242 buf += item_length;
243 length += item_length;
244 item_length = sprintf(buf,"\nWrites: %d Bytes: %lld",
245 atomic_read(&tcon->num_writes),
246 (long long)(tcon->bytes_written));
247 buf += item_length;
248 length += item_length;
249 item_length = sprintf(buf,
250 "\nOpens: %d Deletes: %d\nMkdirs: %d Rmdirs: %d",
251 atomic_read(&tcon->num_opens),
252 atomic_read(&tcon->num_deletes),
253 atomic_read(&tcon->num_mkdirs),
254 atomic_read(&tcon->num_rmdirs));
255 buf += item_length;
256 length += item_length;
257 item_length = sprintf(buf,
258 "\nRenames: %d T2 Renames %d",
259 atomic_read(&tcon->num_renames),
260 atomic_read(&tcon->num_t2renames));
261 buf += item_length;
262 length += item_length;
263 }
264 read_unlock(&GlobalSMBSeslock);
265
266 buf += sprintf(buf,"\n");
267 length++;
268
269 if(offset + count >= length)
270 *eof = 1;
271 if(length < offset) {
272 *eof = 1;
273 return 0;
274 } else {
275 length = length - offset;
276 }
277 if (length > count)
278 length = count;
279
280 return length;
281 }
282 #endif
283
284 struct proc_dir_entry *proc_fs_cifs;
285 read_proc_t cifs_txanchor_read;
286 static read_proc_t cifsFYI_read;
287 static write_proc_t cifsFYI_write;
288 static read_proc_t oplockEnabled_read;
289 static write_proc_t oplockEnabled_write;
290 static read_proc_t lookupFlag_read;
291 static write_proc_t lookupFlag_write;
292 static read_proc_t traceSMB_read;
293 static write_proc_t traceSMB_write;
294 static read_proc_t multiuser_mount_read;
295 static write_proc_t multiuser_mount_write;
296 static read_proc_t extended_security_read;
297 static write_proc_t extended_security_write;
298 static read_proc_t ntlmv2_enabled_read;
299 static write_proc_t ntlmv2_enabled_write;
300 static read_proc_t packet_signing_enabled_read;
301 static write_proc_t packet_signing_enabled_write;
302 static read_proc_t quotaEnabled_read;
303 static write_proc_t quotaEnabled_write;
304 static read_proc_t linuxExtensionsEnabled_read;
305 static write_proc_t linuxExtensionsEnabled_write;
306
307 void
308 cifs_proc_init(void)
309 {
310 struct proc_dir_entry *pde;
311
312 proc_fs_cifs = proc_mkdir("cifs", proc_root_fs);
313 if (proc_fs_cifs == NULL)
314 return;
315
316 proc_fs_cifs->owner = THIS_MODULE;
317 create_proc_read_entry("DebugData", 0, proc_fs_cifs,
318 cifs_debug_data_read, NULL);
319
320 #ifdef CONFIG_CIFS_STATS
321 create_proc_read_entry("Stats", 0, proc_fs_cifs,
322 cifs_stats_read, NULL);
323 #endif
324 pde = create_proc_read_entry("cifsFYI", 0, proc_fs_cifs,
325 cifsFYI_read, NULL);
326 if (pde)
327 pde->write_proc = cifsFYI_write;
328
329 pde =
330 create_proc_read_entry("traceSMB", 0, proc_fs_cifs,
331 traceSMB_read, NULL);
332 if (pde)
333 pde->write_proc = traceSMB_write;
334
335 pde = create_proc_read_entry("OplockEnabled", 0, proc_fs_cifs,
336 oplockEnabled_read, NULL);
337 if (pde)
338 pde->write_proc = oplockEnabled_write;
339
340 pde = create_proc_read_entry("QuotaEnabled", 0, proc_fs_cifs,
341 quotaEnabled_read, NULL);
342 if (pde)
343 pde->write_proc = quotaEnabled_write;
344
345 pde = create_proc_read_entry("LinuxExtensionsEnabled", 0, proc_fs_cifs,
346 linuxExtensionsEnabled_read, NULL);
347 if (pde)
348 pde->write_proc = linuxExtensionsEnabled_write;
349
350 pde =
351 create_proc_read_entry("MultiuserMount", 0, proc_fs_cifs,
352 multiuser_mount_read, NULL);
353 if (pde)
354 pde->write_proc = multiuser_mount_write;
355
356 pde =
357 create_proc_read_entry("ExtendedSecurity", 0, proc_fs_cifs,
358 extended_security_read, NULL);
359 if (pde)
360 pde->write_proc = extended_security_write;
361
362 pde =
363 create_proc_read_entry("LookupCacheEnabled", 0, proc_fs_cifs,
364 lookupFlag_read, NULL);
365 if (pde)
366 pde->write_proc = lookupFlag_write;
367
368 pde =
369 create_proc_read_entry("NTLMV2Enabled", 0, proc_fs_cifs,
370 ntlmv2_enabled_read, NULL);
371 if (pde)
372 pde->write_proc = ntlmv2_enabled_write;
373
374 pde =
375 create_proc_read_entry("PacketSigningEnabled", 0, proc_fs_cifs,
376 packet_signing_enabled_read, NULL);
377 if (pde)
378 pde->write_proc = packet_signing_enabled_write;
379 }
380
381 void
382 cifs_proc_clean(void)
383 {
384 if (proc_fs_cifs == NULL)
385 return;
386
387 remove_proc_entry("DebugData", proc_fs_cifs);
388 remove_proc_entry("cifsFYI", proc_fs_cifs);
389 remove_proc_entry("traceSMB", proc_fs_cifs);
390 #ifdef CONFIG_CIFS_STATS
391 remove_proc_entry("Stats", proc_fs_cifs);
392 #endif
393 remove_proc_entry("MultiuserMount", proc_fs_cifs);
394 remove_proc_entry("OplockEnabled", proc_fs_cifs);
395 remove_proc_entry("NTLMV2Enabled",proc_fs_cifs);
396 remove_proc_entry("ExtendedSecurity",proc_fs_cifs);
397 remove_proc_entry("PacketSigningEnabled",proc_fs_cifs);
398 remove_proc_entry("LinuxExtensionsEnabled",proc_fs_cifs);
399 remove_proc_entry("QuotaEnabled",proc_fs_cifs);
400 remove_proc_entry("LookupCacheEnabled",proc_fs_cifs);
401 remove_proc_entry("cifs", proc_root_fs);
402 }
403
404 static int
405 cifsFYI_read(char *page, char **start, off_t off, int count,
406 int *eof, void *data)
407 {
408 int len;
409
410 len = sprintf(page, "%d\n", cifsFYI);
411
412 len -= off;
413 *start = page + off;
414
415 if (len > count)
416 len = count;
417 else
418 *eof = 1;
419
420 if (len < 0)
421 len = 0;
422
423 return len;
424 }
425 static int
426 cifsFYI_write(struct file *file, const char __user *buffer,
427 unsigned long count, void *data)
428 {
429 char c;
430 int rc;
431
432 rc = get_user(c, buffer);
433 if (rc)
434 return rc;
435 if (c == '0' || c == 'n' || c == 'N')
436 cifsFYI = 0;
437 else if (c == '1' || c == 'y' || c == 'Y')
438 cifsFYI = 1;
439
440 return count;
441 }
442
443 static int
444 oplockEnabled_read(char *page, char **start, off_t off,
445 int count, int *eof, void *data)
446 {
447 int len;
448
449 len = sprintf(page, "%d\n", oplockEnabled);
450
451 len -= off;
452 *start = page + off;
453
454 if (len > count)
455 len = count;
456 else
457 *eof = 1;
458
459 if (len < 0)
460 len = 0;
461
462 return len;
463 }
464 static int
465 oplockEnabled_write(struct file *file, const char __user *buffer,
466 unsigned long count, void *data)
467 {
468 char c;
469 int rc;
470
471 rc = get_user(c, buffer);
472 if (rc)
473 return rc;
474 if (c == '0' || c == 'n' || c == 'N')
475 oplockEnabled = 0;
476 else if (c == '1' || c == 'y' || c == 'Y')
477 oplockEnabled = 1;
478
479 return count;
480 }
481
482 static int
483 quotaEnabled_read(char *page, char **start, off_t off,
484 int count, int *eof, void *data)
485 {
486 int len;
487
488 len = sprintf(page, "%d\n", quotaEnabled);
489 /* could also check if quotas are enabled in kernel
490 as a whole first */
491 len -= off;
492 *start = page + off;
493
494 if (len > count)
495 len = count;
496 else
497 *eof = 1;
498
499 if (len < 0)
500 len = 0;
501
502 return len;
503 }
504 static int
505 quotaEnabled_write(struct file *file, const char __user *buffer,
506 unsigned long count, void *data)
507 {
508 char c;
509 int rc;
510
511 rc = get_user(c, buffer);
512 if (rc)
513 return rc;
514 if (c == '0' || c == 'n' || c == 'N')
515 quotaEnabled = 0;
516 else if (c == '1' || c == 'y' || c == 'Y')
517 quotaEnabled = 1;
518
519 return count;
520 }
521
522 static int
523 linuxExtensionsEnabled_read(char *page, char **start, off_t off,
524 int count, int *eof, void *data)
525 {
526 int len;
527
528 len = sprintf(page, "%d\n", linuxExtEnabled);
529 /* could also check if quotas are enabled in kernel
530 as a whole first */
531 len -= off;
532 *start = page + off;
533
534 if (len > count)
535 len = count;
536 else
537 *eof = 1;
538
539 if (len < 0)
540 len = 0;
541
542 return len;
543 }
544 static int
545 linuxExtensionsEnabled_write(struct file *file, const char __user *buffer,
546 unsigned long count, void *data)
547 {
548 char c;
549 int rc;
550
551 rc = get_user(c, buffer);
552 if (rc)
553 return rc;
554 if (c == '0' || c == 'n' || c == 'N')
555 linuxExtEnabled = 0;
556 else if (c == '1' || c == 'y' || c == 'Y')
557 linuxExtEnabled = 1;
558
559 return count;
560 }
561
562
563 static int
564 lookupFlag_read(char *page, char **start, off_t off,
565 int count, int *eof, void *data)
566 {
567 int len;
568
569 len = sprintf(page, "%d\n", lookupCacheEnabled);
570
571 len -= off;
572 *start = page + off;
573
574 if (len > count)
575 len = count;
576 else
577 *eof = 1;
578
579 if (len < 0)
580 len = 0;
581
582 return len;
583 }
584 static int
585 lookupFlag_write(struct file *file, const char __user *buffer,
586 unsigned long count, void *data)
587 {
588 char c;
589 int rc;
590
591 rc = get_user(c, buffer);
592 if (rc)
593 return rc;
594 if (c == '0' || c == 'n' || c == 'N')
595 lookupCacheEnabled = 0;
596 else if (c == '1' || c == 'y' || c == 'Y')
597 lookupCacheEnabled = 1;
598
599 return count;
600 }
601 static int
602 traceSMB_read(char *page, char **start, off_t off, int count,
603 int *eof, void *data)
604 {
605 int len;
606
607 len = sprintf(page, "%d\n", traceSMB);
608
609 len -= off;
610 *start = page + off;
611
612 if (len > count)
613 len = count;
614 else
615 *eof = 1;
616
617 if (len < 0)
618 len = 0;
619
620 return len;
621 }
622 static int
623 traceSMB_write(struct file *file, const char __user *buffer,
624 unsigned long count, void *data)
625 {
626 char c;
627 int rc;
628
629 rc = get_user(c, buffer);
630 if (rc)
631 return rc;
632 if (c == '0' || c == 'n' || c == 'N')
633 traceSMB = 0;
634 else if (c == '1' || c == 'y' || c == 'Y')
635 traceSMB = 1;
636
637 return count;
638 }
639
640 static int
641 multiuser_mount_read(char *page, char **start, off_t off,
642 int count, int *eof, void *data)
643 {
644 int len;
645
646 len = sprintf(page, "%d\n", multiuser_mount);
647
648 len -= off;
649 *start = page + off;
650
651 if (len > count)
652 len = count;
653 else
654 *eof = 1;
655
656 if (len < 0)
657 len = 0;
658
659 return len;
660 }
661 static int
662 multiuser_mount_write(struct file *file, const char __user *buffer,
663 unsigned long count, void *data)
664 {
665 char c;
666 int rc;
667
668 rc = get_user(c, buffer);
669 if (rc)
670 return rc;
671 if (c == '0' || c == 'n' || c == 'N')
672 multiuser_mount = 0;
673 else if (c == '1' || c == 'y' || c == 'Y')
674 multiuser_mount = 1;
675
676 return count;
677 }
678
679 static int
680 extended_security_read(char *page, char **start, off_t off,
681 int count, int *eof, void *data)
682 {
683 int len;
684
685 len = sprintf(page, "%d\n", extended_security);
686
687 len -= off;
688 *start = page + off;
689
690 if (len > count)
691 len = count;
692 else
693 *eof = 1;
694
695 if (len < 0)
696 len = 0;
697
698 return len;
699 }
700 static int
701 extended_security_write(struct file *file, const char __user *buffer,
702 unsigned long count, void *data)
703 {
704 char c;
705 int rc;
706
707 rc = get_user(c, buffer);
708 if (rc)
709 return rc;
710 if (c == '0' || c == 'n' || c == 'N')
711 extended_security = 0;
712 else if (c == '1' || c == 'y' || c == 'Y')
713 extended_security = 1;
714
715 return count;
716 }
717
718 static int
719 ntlmv2_enabled_read(char *page, char **start, off_t off,
720 int count, int *eof, void *data)
721 {
722 int len;
723
724 len = sprintf(page, "%d\n", ntlmv2_support);
725
726 len -= off;
727 *start = page + off;
728
729 if (len > count)
730 len = count;
731 else
732 *eof = 1;
733
734 if (len < 0)
735 len = 0;
736
737 return len;
738 }
739 static int
740 ntlmv2_enabled_write(struct file *file, const char __user *buffer,
741 unsigned long count, void *data)
742 {
743 char c;
744 int rc;
745
746 rc = get_user(c, buffer);
747 if (rc)
748 return rc;
749 if (c == '0' || c == 'n' || c == 'N')
750 ntlmv2_support = 0;
751 else if (c == '1' || c == 'y' || c == 'Y')
752 ntlmv2_support = 1;
753
754 return count;
755 }
756
757 static int
758 packet_signing_enabled_read(char *page, char **start, off_t off,
759 int count, int *eof, void *data)
760 {
761 int len;
762
763 len = sprintf(page, "%d\n", sign_CIFS_PDUs);
764
765 len -= off;
766 *start = page + off;
767
768 if (len > count)
769 len = count;
770 else
771 *eof = 1;
772
773 if (len < 0)
774 len = 0;
775
776 return len;
777 }
778 static int
779 packet_signing_enabled_write(struct file *file, const char __user *buffer,
780 unsigned long count, void *data)
781 {
782 char c;
783 int rc;
784
785 rc = get_user(c, buffer);
786 if (rc)
787 return rc;
788 if (c == '0' || c == 'n' || c == 'N')
789 sign_CIFS_PDUs = 0;
790 else if (c == '1' || c == 'y' || c == 'Y')
791 sign_CIFS_PDUs = 1;
792 else if (c == '2')
793 sign_CIFS_PDUs = 2;
794
795 return count;
796 }
797
798
799 #endif
MOXA 2.6.9 from sdlinux-moxaart.tgz