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