ia64/linux-2.6.18-xen.hg

view fs/cifs/cifs_debug.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
1 /*
2 * fs/cifs_debug.c
3 *
4 * Copyright (C) International Business Machines Corp., 2000,2005
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 #include "cifsfs.h"
34 void
35 cifs_dump_mem(char *label, void *data, int length)
36 {
37 int i, j;
38 int *intptr = data;
39 char *charptr = data;
40 char buf[10], line[80];
42 printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n",
43 label, length, data);
44 for (i = 0; i < length; i += 16) {
45 line[0] = 0;
46 for (j = 0; (j < 4) && (i + j * 4 < length); j++) {
47 sprintf(buf, " %08x", intptr[i / 4 + j]);
48 strcat(line, buf);
49 }
50 buf[0] = ' ';
51 buf[2] = 0;
52 for (j = 0; (j < 16) && (i + j < length); j++) {
53 buf[1] = isprint(charptr[i + j]) ? charptr[i + j] : '.';
54 strcat(line, buf);
55 }
56 printk(KERN_DEBUG "%s\n", line);
57 }
58 }
60 #ifdef CONFIG_CIFS_DEBUG2
61 void cifs_dump_detail(struct smb_hdr * smb)
62 {
63 cERROR(1,("Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d",
64 smb->Command, smb->Status.CifsError,
65 smb->Flags, smb->Flags2, smb->Mid, smb->Pid));
66 cERROR(1,("smb buf %p len %d", smb, smbCalcSize_LE(smb)));
67 }
70 void cifs_dump_mids(struct TCP_Server_Info * server)
71 {
72 struct list_head *tmp;
73 struct mid_q_entry * mid_entry;
75 if(server == NULL)
76 return;
78 cERROR(1,("Dump pending requests:"));
79 spin_lock(&GlobalMid_Lock);
80 list_for_each(tmp, &server->pending_mid_q) {
81 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
82 if(mid_entry) {
83 cERROR(1,("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d",
84 mid_entry->midState,
85 (int)mid_entry->command,
86 mid_entry->pid,
87 mid_entry->tsk,
88 mid_entry->mid));
89 #ifdef CONFIG_CIFS_STATS2
90 cERROR(1,("IsLarge: %d buf: %p time rcv: %ld now: %ld",
91 mid_entry->largeBuf,
92 mid_entry->resp_buf,
93 mid_entry->when_received,
94 jiffies));
95 #endif /* STATS2 */
96 cERROR(1,("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
97 mid_entry->multiEnd));
98 if(mid_entry->resp_buf) {
99 cifs_dump_detail(mid_entry->resp_buf);
100 cifs_dump_mem("existing buf: ",
101 mid_entry->resp_buf,
102 62 /* fixme */);
103 }
105 }
106 }
107 spin_unlock(&GlobalMid_Lock);
108 }
109 #endif /* CONFIG_CIFS_DEBUG2 */
111 #ifdef CONFIG_PROC_FS
112 static int
113 cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
114 int count, int *eof, void *data)
115 {
116 struct list_head *tmp;
117 struct list_head *tmp1;
118 struct mid_q_entry * mid_entry;
119 struct cifsSesInfo *ses;
120 struct cifsTconInfo *tcon;
121 int i;
122 int length = 0;
123 char * original_buf = buf;
125 *beginBuffer = buf + offset;
127 length =
128 sprintf(buf,
129 "Display Internal CIFS Data Structures for Debugging\n"
130 "---------------------------------------------------\n");
131 buf += length;
132 length = sprintf(buf,"CIFS Version %s\n",CIFS_VERSION);
133 buf += length;
134 length = sprintf(buf,"Active VFS Requests: %d\n", GlobalTotalActiveXid);
135 buf += length;
136 length = sprintf(buf, "Servers:");
137 buf += length;
139 i = 0;
140 read_lock(&GlobalSMBSeslock);
141 list_for_each(tmp, &GlobalSMBSessionList) {
142 i++;
143 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
144 if((ses->serverDomain == NULL) || (ses->serverOS == NULL) ||
145 (ses->serverNOS == NULL)) {
146 buf += sprintf("\nentry for %s not fully displayed\n\t",
147 ses->serverName);
149 } else {
150 length =
151 sprintf(buf,
152 "\n%d) Name: %s Domain: %s Mounts: %d OS: %s \n\tNOS: %s\tCapability: 0x%x\n\tSMB session status: %d\t",
153 i, ses->serverName, ses->serverDomain,
154 atomic_read(&ses->inUse),
155 ses->serverOS, ses->serverNOS,
156 ses->capabilities,ses->status);
157 buf += length;
158 }
159 if(ses->server) {
160 buf += sprintf(buf, "TCP status: %d\n\tLocal Users To Server: %d SecMode: 0x%x Req On Wire: %d",
161 ses->server->tcpStatus,
162 atomic_read(&ses->server->socketUseCount),
163 ses->server->secMode,
164 atomic_read(&ses->server->inFlight));
166 #ifdef CONFIG_CIFS_STATS2
167 buf += sprintf(buf, " In Send: %d In MaxReq Wait: %d",
168 atomic_read(&ses->server->inSend),
169 atomic_read(&ses->server->num_waiters));
170 #endif
172 length = sprintf(buf, "\nMIDs:\n");
173 buf += length;
175 spin_lock(&GlobalMid_Lock);
176 list_for_each(tmp1, &ses->server->pending_mid_q) {
177 mid_entry = list_entry(tmp1, struct
178 mid_q_entry,
179 qhead);
180 if(mid_entry) {
181 length = sprintf(buf,"State: %d com: %d pid: %d tsk: %p mid %d\n",
182 mid_entry->midState,
183 (int)mid_entry->command,
184 mid_entry->pid,
185 mid_entry->tsk,
186 mid_entry->mid);
187 buf += length;
188 }
189 }
190 spin_unlock(&GlobalMid_Lock);
191 }
193 }
194 read_unlock(&GlobalSMBSeslock);
195 sprintf(buf, "\n");
196 buf++;
198 length = sprintf(buf, "Shares:");
199 buf += length;
201 i = 0;
202 read_lock(&GlobalSMBSeslock);
203 list_for_each(tmp, &GlobalTreeConnectionList) {
204 __u32 dev_type;
205 i++;
206 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
207 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
208 length =
209 sprintf(buf,
210 "\n%d) %s Uses: %d Type: %s DevInfo: 0x%x Attributes: 0x%x\nPathComponentMax: %d Status: %d",
211 i, tcon->treeName,
212 atomic_read(&tcon->useCount),
213 tcon->nativeFileSystem,
214 le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
215 le32_to_cpu(tcon->fsAttrInfo.Attributes),
216 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
217 tcon->tidStatus);
218 buf += length;
219 if (dev_type == FILE_DEVICE_DISK)
220 length = sprintf(buf, " type: DISK ");
221 else if (dev_type == FILE_DEVICE_CD_ROM)
222 length = sprintf(buf, " type: CDROM ");
223 else
224 length =
225 sprintf(buf, " type: %d ", dev_type);
226 buf += length;
227 if(tcon->tidStatus == CifsNeedReconnect) {
228 buf += sprintf(buf, "\tDISCONNECTED ");
229 length += 14;
230 }
231 }
232 read_unlock(&GlobalSMBSeslock);
234 length = sprintf(buf, "\n");
235 buf += length;
237 /* BB add code to dump additional info such as TCP session info now */
238 /* Now calculate total size of returned data */
239 length = buf - original_buf;
241 if(offset + count >= length)
242 *eof = 1;
243 if(length < offset) {
244 *eof = 1;
245 return 0;
246 } else {
247 length = length - offset;
248 }
249 if (length > count)
250 length = count;
252 return length;
253 }
255 #ifdef CONFIG_CIFS_STATS
257 static int
258 cifs_stats_write(struct file *file, const char __user *buffer,
259 unsigned long count, void *data)
260 {
261 char c;
262 int rc;
263 struct list_head *tmp;
264 struct cifsTconInfo *tcon;
266 rc = get_user(c, buffer);
267 if (rc)
268 return rc;
270 if (c == '1' || c == 'y' || c == 'Y' || c == '0') {
271 read_lock(&GlobalSMBSeslock);
272 #ifdef CONFIG_CIFS_STATS2
273 atomic_set(&totBufAllocCount, 0);
274 atomic_set(&totSmBufAllocCount, 0);
275 #endif /* CONFIG_CIFS_STATS2 */
276 list_for_each(tmp, &GlobalTreeConnectionList) {
277 tcon = list_entry(tmp, struct cifsTconInfo,
278 cifsConnectionList);
279 atomic_set(&tcon->num_smbs_sent, 0);
280 atomic_set(&tcon->num_writes, 0);
281 atomic_set(&tcon->num_reads, 0);
282 atomic_set(&tcon->num_oplock_brks, 0);
283 atomic_set(&tcon->num_opens, 0);
284 atomic_set(&tcon->num_closes, 0);
285 atomic_set(&tcon->num_deletes, 0);
286 atomic_set(&tcon->num_mkdirs, 0);
287 atomic_set(&tcon->num_rmdirs, 0);
288 atomic_set(&tcon->num_renames, 0);
289 atomic_set(&tcon->num_t2renames, 0);
290 atomic_set(&tcon->num_ffirst, 0);
291 atomic_set(&tcon->num_fnext, 0);
292 atomic_set(&tcon->num_fclose, 0);
293 atomic_set(&tcon->num_hardlinks, 0);
294 atomic_set(&tcon->num_symlinks, 0);
295 atomic_set(&tcon->num_locks, 0);
296 }
297 read_unlock(&GlobalSMBSeslock);
298 }
300 return count;
301 }
303 static int
304 cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
305 int count, int *eof, void *data)
306 {
307 int item_length,i,length;
308 struct list_head *tmp;
309 struct cifsTconInfo *tcon;
311 *beginBuffer = buf + offset;
313 length = sprintf(buf,
314 "Resources in use\nCIFS Session: %d\n",
315 sesInfoAllocCount.counter);
316 buf += length;
317 item_length =
318 sprintf(buf,"Share (unique mount targets): %d\n",
319 tconInfoAllocCount.counter);
320 length += item_length;
321 buf += item_length;
322 item_length =
323 sprintf(buf,"SMB Request/Response Buffer: %d Pool size: %d\n",
324 bufAllocCount.counter,
325 cifs_min_rcv + tcpSesAllocCount.counter);
326 length += item_length;
327 buf += item_length;
328 item_length =
329 sprintf(buf,"SMB Small Req/Resp Buffer: %d Pool size: %d\n",
330 smBufAllocCount.counter,cifs_min_small);
331 length += item_length;
332 buf += item_length;
333 #ifdef CONFIG_CIFS_STATS2
334 item_length = sprintf(buf, "Total Large %d Small %d Allocations\n",
335 atomic_read(&totBufAllocCount),
336 atomic_read(&totSmBufAllocCount));
337 length += item_length;
338 buf += item_length;
339 #endif /* CONFIG_CIFS_STATS2 */
341 item_length =
342 sprintf(buf,"Operations (MIDs): %d\n",
343 midCount.counter);
344 length += item_length;
345 buf += item_length;
346 item_length = sprintf(buf,
347 "\n%d session %d share reconnects\n",
348 tcpSesReconnectCount.counter,tconInfoReconnectCount.counter);
349 length += item_length;
350 buf += item_length;
352 item_length = sprintf(buf,
353 "Total vfs operations: %d maximum at one time: %d\n",
354 GlobalCurrentXid,GlobalMaxActiveXid);
355 length += item_length;
356 buf += item_length;
358 i = 0;
359 read_lock(&GlobalSMBSeslock);
360 list_for_each(tmp, &GlobalTreeConnectionList) {
361 i++;
362 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
363 item_length = sprintf(buf,"\n%d) %s",i, tcon->treeName);
364 buf += item_length;
365 length += item_length;
366 if(tcon->tidStatus == CifsNeedReconnect) {
367 buf += sprintf(buf, "\tDISCONNECTED ");
368 length += 14;
369 }
370 item_length = sprintf(buf, "\nSMBs: %d Oplock Breaks: %d",
371 atomic_read(&tcon->num_smbs_sent),
372 atomic_read(&tcon->num_oplock_brks));
373 buf += item_length;
374 length += item_length;
375 item_length = sprintf(buf, "\nReads: %d Bytes: %lld",
376 atomic_read(&tcon->num_reads),
377 (long long)(tcon->bytes_read));
378 buf += item_length;
379 length += item_length;
380 item_length = sprintf(buf, "\nWrites: %d Bytes: %lld",
381 atomic_read(&tcon->num_writes),
382 (long long)(tcon->bytes_written));
383 buf += item_length;
384 length += item_length;
385 item_length = sprintf(buf,
386 "\nLocks: %d HardLinks: %d Symlinks: %d",
387 atomic_read(&tcon->num_locks),
388 atomic_read(&tcon->num_hardlinks),
389 atomic_read(&tcon->num_symlinks));
390 buf += item_length;
391 length += item_length;
393 item_length = sprintf(buf, "\nOpens: %d Closes: %d Deletes: %d",
394 atomic_read(&tcon->num_opens),
395 atomic_read(&tcon->num_closes),
396 atomic_read(&tcon->num_deletes));
397 buf += item_length;
398 length += item_length;
399 item_length = sprintf(buf, "\nMkdirs: %d Rmdirs: %d",
400 atomic_read(&tcon->num_mkdirs),
401 atomic_read(&tcon->num_rmdirs));
402 buf += item_length;
403 length += item_length;
404 item_length = sprintf(buf, "\nRenames: %d T2 Renames %d",
405 atomic_read(&tcon->num_renames),
406 atomic_read(&tcon->num_t2renames));
407 buf += item_length;
408 length += item_length;
409 item_length = sprintf(buf, "\nFindFirst: %d FNext %d FClose %d",
410 atomic_read(&tcon->num_ffirst),
411 atomic_read(&tcon->num_fnext),
412 atomic_read(&tcon->num_fclose));
413 buf += item_length;
414 length += item_length;
415 }
416 read_unlock(&GlobalSMBSeslock);
418 buf += sprintf(buf,"\n");
419 length++;
421 if(offset + count >= length)
422 *eof = 1;
423 if(length < offset) {
424 *eof = 1;
425 return 0;
426 } else {
427 length = length - offset;
428 }
429 if (length > count)
430 length = count;
432 return length;
433 }
434 #endif
436 static struct proc_dir_entry *proc_fs_cifs;
437 read_proc_t cifs_txanchor_read;
438 static read_proc_t cifsFYI_read;
439 static write_proc_t cifsFYI_write;
440 static read_proc_t oplockEnabled_read;
441 static write_proc_t oplockEnabled_write;
442 static read_proc_t lookupFlag_read;
443 static write_proc_t lookupFlag_write;
444 static read_proc_t traceSMB_read;
445 static write_proc_t traceSMB_write;
446 static read_proc_t multiuser_mount_read;
447 static write_proc_t multiuser_mount_write;
448 static read_proc_t security_flags_read;
449 static write_proc_t security_flags_write;
450 /* static read_proc_t ntlmv2_enabled_read;
451 static write_proc_t ntlmv2_enabled_write;
452 static read_proc_t packet_signing_enabled_read;
453 static write_proc_t packet_signing_enabled_write;*/
454 static read_proc_t experimEnabled_read;
455 static write_proc_t experimEnabled_write;
456 static read_proc_t linuxExtensionsEnabled_read;
457 static write_proc_t linuxExtensionsEnabled_write;
459 void
460 cifs_proc_init(void)
461 {
462 struct proc_dir_entry *pde;
464 proc_fs_cifs = proc_mkdir("cifs", proc_root_fs);
465 if (proc_fs_cifs == NULL)
466 return;
468 proc_fs_cifs->owner = THIS_MODULE;
469 create_proc_read_entry("DebugData", 0, proc_fs_cifs,
470 cifs_debug_data_read, NULL);
472 #ifdef CONFIG_CIFS_STATS
473 pde = create_proc_read_entry("Stats", 0, proc_fs_cifs,
474 cifs_stats_read, NULL);
475 if (pde)
476 pde->write_proc = cifs_stats_write;
477 #endif
478 pde = create_proc_read_entry("cifsFYI", 0, proc_fs_cifs,
479 cifsFYI_read, NULL);
480 if (pde)
481 pde->write_proc = cifsFYI_write;
483 pde =
484 create_proc_read_entry("traceSMB", 0, proc_fs_cifs,
485 traceSMB_read, NULL);
486 if (pde)
487 pde->write_proc = traceSMB_write;
489 pde = create_proc_read_entry("OplockEnabled", 0, proc_fs_cifs,
490 oplockEnabled_read, NULL);
491 if (pde)
492 pde->write_proc = oplockEnabled_write;
494 pde = create_proc_read_entry("Experimental", 0, proc_fs_cifs,
495 experimEnabled_read, NULL);
496 if (pde)
497 pde->write_proc = experimEnabled_write;
499 pde = create_proc_read_entry("LinuxExtensionsEnabled", 0, proc_fs_cifs,
500 linuxExtensionsEnabled_read, NULL);
501 if (pde)
502 pde->write_proc = linuxExtensionsEnabled_write;
504 pde =
505 create_proc_read_entry("MultiuserMount", 0, proc_fs_cifs,
506 multiuser_mount_read, NULL);
507 if (pde)
508 pde->write_proc = multiuser_mount_write;
510 pde =
511 create_proc_read_entry("SecurityFlags", 0, proc_fs_cifs,
512 security_flags_read, NULL);
513 if (pde)
514 pde->write_proc = security_flags_write;
516 pde =
517 create_proc_read_entry("LookupCacheEnabled", 0, proc_fs_cifs,
518 lookupFlag_read, NULL);
519 if (pde)
520 pde->write_proc = lookupFlag_write;
522 /* pde =
523 create_proc_read_entry("NTLMV2Enabled", 0, proc_fs_cifs,
524 ntlmv2_enabled_read, NULL);
525 if (pde)
526 pde->write_proc = ntlmv2_enabled_write;
528 pde =
529 create_proc_read_entry("PacketSigningEnabled", 0, proc_fs_cifs,
530 packet_signing_enabled_read, NULL);
531 if (pde)
532 pde->write_proc = packet_signing_enabled_write;*/
533 }
535 void
536 cifs_proc_clean(void)
537 {
538 if (proc_fs_cifs == NULL)
539 return;
541 remove_proc_entry("DebugData", proc_fs_cifs);
542 remove_proc_entry("cifsFYI", proc_fs_cifs);
543 remove_proc_entry("traceSMB", proc_fs_cifs);
544 #ifdef CONFIG_CIFS_STATS
545 remove_proc_entry("Stats", proc_fs_cifs);
546 #endif
547 remove_proc_entry("MultiuserMount", proc_fs_cifs);
548 remove_proc_entry("OplockEnabled", proc_fs_cifs);
549 /* remove_proc_entry("NTLMV2Enabled",proc_fs_cifs); */
550 remove_proc_entry("SecurityFlags",proc_fs_cifs);
551 /* remove_proc_entry("PacketSigningEnabled",proc_fs_cifs); */
552 remove_proc_entry("LinuxExtensionsEnabled",proc_fs_cifs);
553 remove_proc_entry("Experimental",proc_fs_cifs);
554 remove_proc_entry("LookupCacheEnabled",proc_fs_cifs);
555 remove_proc_entry("cifs", proc_root_fs);
556 }
558 static int
559 cifsFYI_read(char *page, char **start, off_t off, int count,
560 int *eof, void *data)
561 {
562 int len;
564 len = sprintf(page, "%d\n", cifsFYI);
566 len -= off;
567 *start = page + off;
569 if (len > count)
570 len = count;
571 else
572 *eof = 1;
574 if (len < 0)
575 len = 0;
577 return len;
578 }
579 static int
580 cifsFYI_write(struct file *file, const char __user *buffer,
581 unsigned long count, void *data)
582 {
583 char c;
584 int rc;
586 rc = get_user(c, buffer);
587 if (rc)
588 return rc;
589 if (c == '0' || c == 'n' || c == 'N')
590 cifsFYI = 0;
591 else if (c == '1' || c == 'y' || c == 'Y')
592 cifsFYI = 1;
593 else if((c > '1') && (c <= '9'))
594 cifsFYI = (int) (c - '0'); /* see cifs_debug.h for meanings */
596 return count;
597 }
599 static int
600 oplockEnabled_read(char *page, char **start, off_t off,
601 int count, int *eof, void *data)
602 {
603 int len;
605 len = sprintf(page, "%d\n", oplockEnabled);
607 len -= off;
608 *start = page + off;
610 if (len > count)
611 len = count;
612 else
613 *eof = 1;
615 if (len < 0)
616 len = 0;
618 return len;
619 }
620 static int
621 oplockEnabled_write(struct file *file, const char __user *buffer,
622 unsigned long count, void *data)
623 {
624 char c;
625 int rc;
627 rc = get_user(c, buffer);
628 if (rc)
629 return rc;
630 if (c == '0' || c == 'n' || c == 'N')
631 oplockEnabled = 0;
632 else if (c == '1' || c == 'y' || c == 'Y')
633 oplockEnabled = 1;
635 return count;
636 }
638 static int
639 experimEnabled_read(char *page, char **start, off_t off,
640 int count, int *eof, void *data)
641 {
642 int len;
644 len = sprintf(page, "%d\n", experimEnabled);
646 len -= off;
647 *start = page + off;
649 if (len > count)
650 len = count;
651 else
652 *eof = 1;
654 if (len < 0)
655 len = 0;
657 return len;
658 }
659 static int
660 experimEnabled_write(struct file *file, const char __user *buffer,
661 unsigned long count, void *data)
662 {
663 char c;
664 int rc;
666 rc = get_user(c, buffer);
667 if (rc)
668 return rc;
669 if (c == '0' || c == 'n' || c == 'N')
670 experimEnabled = 0;
671 else if (c == '1' || c == 'y' || c == 'Y')
672 experimEnabled = 1;
673 else if (c == '2')
674 experimEnabled = 2;
676 return count;
677 }
679 static int
680 linuxExtensionsEnabled_read(char *page, char **start, off_t off,
681 int count, int *eof, void *data)
682 {
683 int len;
685 len = sprintf(page, "%d\n", linuxExtEnabled);
686 len -= off;
687 *start = page + off;
689 if (len > count)
690 len = count;
691 else
692 *eof = 1;
694 if (len < 0)
695 len = 0;
697 return len;
698 }
699 static int
700 linuxExtensionsEnabled_write(struct file *file, const char __user *buffer,
701 unsigned long count, void *data)
702 {
703 char c;
704 int rc;
706 rc = get_user(c, buffer);
707 if (rc)
708 return rc;
709 if (c == '0' || c == 'n' || c == 'N')
710 linuxExtEnabled = 0;
711 else if (c == '1' || c == 'y' || c == 'Y')
712 linuxExtEnabled = 1;
714 return count;
715 }
718 static int
719 lookupFlag_read(char *page, char **start, off_t off,
720 int count, int *eof, void *data)
721 {
722 int len;
724 len = sprintf(page, "%d\n", lookupCacheEnabled);
726 len -= off;
727 *start = page + off;
729 if (len > count)
730 len = count;
731 else
732 *eof = 1;
734 if (len < 0)
735 len = 0;
737 return len;
738 }
739 static int
740 lookupFlag_write(struct file *file, const char __user *buffer,
741 unsigned long count, void *data)
742 {
743 char c;
744 int rc;
746 rc = get_user(c, buffer);
747 if (rc)
748 return rc;
749 if (c == '0' || c == 'n' || c == 'N')
750 lookupCacheEnabled = 0;
751 else if (c == '1' || c == 'y' || c == 'Y')
752 lookupCacheEnabled = 1;
754 return count;
755 }
756 static int
757 traceSMB_read(char *page, char **start, off_t off, int count,
758 int *eof, void *data)
759 {
760 int len;
762 len = sprintf(page, "%d\n", traceSMB);
764 len -= off;
765 *start = page + off;
767 if (len > count)
768 len = count;
769 else
770 *eof = 1;
772 if (len < 0)
773 len = 0;
775 return len;
776 }
777 static int
778 traceSMB_write(struct file *file, const char __user *buffer,
779 unsigned long count, void *data)
780 {
781 char c;
782 int rc;
784 rc = get_user(c, buffer);
785 if (rc)
786 return rc;
787 if (c == '0' || c == 'n' || c == 'N')
788 traceSMB = 0;
789 else if (c == '1' || c == 'y' || c == 'Y')
790 traceSMB = 1;
792 return count;
793 }
795 static int
796 multiuser_mount_read(char *page, char **start, off_t off,
797 int count, int *eof, void *data)
798 {
799 int len;
801 len = sprintf(page, "%d\n", multiuser_mount);
803 len -= off;
804 *start = page + off;
806 if (len > count)
807 len = count;
808 else
809 *eof = 1;
811 if (len < 0)
812 len = 0;
814 return len;
815 }
816 static int
817 multiuser_mount_write(struct file *file, const char __user *buffer,
818 unsigned long count, void *data)
819 {
820 char c;
821 int rc;
823 rc = get_user(c, buffer);
824 if (rc)
825 return rc;
826 if (c == '0' || c == 'n' || c == 'N')
827 multiuser_mount = 0;
828 else if (c == '1' || c == 'y' || c == 'Y')
829 multiuser_mount = 1;
831 return count;
832 }
834 static int
835 security_flags_read(char *page, char **start, off_t off,
836 int count, int *eof, void *data)
837 {
838 int len;
840 len = sprintf(page, "0x%x\n", extended_security);
842 len -= off;
843 *start = page + off;
845 if (len > count)
846 len = count;
847 else
848 *eof = 1;
850 if (len < 0)
851 len = 0;
853 return len;
854 }
855 static int
856 security_flags_write(struct file *file, const char __user *buffer,
857 unsigned long count, void *data)
858 {
859 unsigned int flags;
860 char flags_string[12];
861 char c;
863 if((count < 1) || (count > 11))
864 return -EINVAL;
866 memset(flags_string, 0, 12);
868 if(copy_from_user(flags_string, buffer, count))
869 return -EFAULT;
871 if(count < 3) {
872 /* single char or single char followed by null */
873 c = flags_string[0];
874 if (c == '0' || c == 'n' || c == 'N')
875 extended_security = CIFSSEC_DEF; /* default */
876 else if (c == '1' || c == 'y' || c == 'Y')
877 extended_security = CIFSSEC_MAX;
878 return count;
879 }
880 /* else we have a number */
882 flags = simple_strtoul(flags_string, NULL, 0);
884 cFYI(1,("sec flags 0x%x", flags));
886 if(flags <= 0) {
887 cERROR(1,("invalid security flags %s",flags_string));
888 return -EINVAL;
889 }
891 if(flags & ~CIFSSEC_MASK) {
892 cERROR(1,("attempt to set unsupported security flags 0x%x",
893 flags & ~CIFSSEC_MASK));
894 return -EINVAL;
895 }
896 /* flags look ok - update the global security flags for cifs module */
897 extended_security = flags;
898 return count;
899 }
901 /* static int
902 ntlmv2_enabled_read(char *page, char **start, off_t off,
903 int count, int *eof, void *data)
904 {
905 int len;
907 len = sprintf(page, "%d\n", ntlmv2_support);
909 len -= off;
910 *start = page + off;
912 if (len > count)
913 len = count;
914 else
915 *eof = 1;
917 if (len < 0)
918 len = 0;
920 return len;
921 }
922 static int
923 ntlmv2_enabled_write(struct file *file, const char __user *buffer,
924 unsigned long count, void *data)
925 {
926 char c;
927 int rc;
929 rc = get_user(c, buffer);
930 if (rc)
931 return rc;
932 if (c == '0' || c == 'n' || c == 'N')
933 ntlmv2_support = 0;
934 else if (c == '1' || c == 'y' || c == 'Y')
935 ntlmv2_support = 1;
936 else if (c == '2')
937 ntlmv2_support = 2;
939 return count;
940 }
942 static int
943 packet_signing_enabled_read(char *page, char **start, off_t off,
944 int count, int *eof, void *data)
945 {
946 int len;
948 len = sprintf(page, "%d\n", sign_CIFS_PDUs);
950 len -= off;
951 *start = page + off;
953 if (len > count)
954 len = count;
955 else
956 *eof = 1;
958 if (len < 0)
959 len = 0;
961 return len;
962 }
963 static int
964 packet_signing_enabled_write(struct file *file, const char __user *buffer,
965 unsigned long count, void *data)
966 {
967 char c;
968 int rc;
970 rc = get_user(c, buffer);
971 if (rc)
972 return rc;
973 if (c == '0' || c == 'n' || c == 'N')
974 sign_CIFS_PDUs = 0;
975 else if (c == '1' || c == 'y' || c == 'Y')
976 sign_CIFS_PDUs = 1;
977 else if (c == '2')
978 sign_CIFS_PDUs = 2;
980 return count;
981 } */
984 #endif