[CIFS] Fix warnings from checkpatch
[linux-2.6.git] / fs / cifs / cifs_debug.c
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"
33
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];
41
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 }
59
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 }
68
69
70 void cifs_dump_mids(struct TCP_Server_Info *server)
71 {
72         struct list_head *tmp;
73         struct mid_q_entry *mid_entry;
74
75         if (server == NULL)
76                 return;
77
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, 62);
102                         }
103                 }
104         }
105         spin_unlock(&GlobalMid_Lock);
106 }
107 #endif /* CONFIG_CIFS_DEBUG2 */
108
109 #ifdef CONFIG_PROC_FS
110 static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
111 {
112         struct list_head *tmp;
113         struct list_head *tmp1;
114         struct mid_q_entry *mid_entry;
115         struct cifsSesInfo *ses;
116         struct cifsTconInfo *tcon;
117         int i;
118
119         seq_puts(m,
120                     "Display Internal CIFS Data Structures for Debugging\n"
121                     "---------------------------------------------------\n");
122         seq_printf(m, "CIFS Version %s\n", CIFS_VERSION);
123         seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid);
124         seq_printf(m, "Servers:");
125
126         i = 0;
127         read_lock(&GlobalSMBSeslock);
128         list_for_each(tmp, &GlobalSMBSessionList) {
129                 i++;
130                 ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
131                 if ((ses->serverDomain == NULL) || (ses->serverOS == NULL) ||
132                    (ses->serverNOS == NULL)) {
133                         seq_printf(m, "\nentry for %s not fully "
134                                         "displayed\n\t", ses->serverName);
135                 } else {
136                         seq_printf(m,
137                                     "\n%d) Name: %s  Domain: %s Mounts: %d OS:"
138                                     " %s  \n\tNOS: %s\tCapability: 0x%x\n\tSMB"
139                                     " session status: %d\t",
140                                 i, ses->serverName, ses->serverDomain,
141                                 atomic_read(&ses->inUse),
142                                 ses->serverOS, ses->serverNOS,
143                                 ses->capabilities, ses->status);
144                 }
145                 if (ses->server) {
146                         seq_printf(m, "TCP status: %d\n\tLocal Users To "
147                                     "Server: %d SecMode: 0x%x Req On Wire: %d",
148                                 ses->server->tcpStatus,
149                                 atomic_read(&ses->server->socketUseCount),
150                                 ses->server->secMode,
151                                 atomic_read(&ses->server->inFlight));
152
153 #ifdef CONFIG_CIFS_STATS2
154                         seq_printf(m, " In Send: %d In MaxReq Wait: %d",
155                                 atomic_read(&ses->server->inSend),
156                                 atomic_read(&ses->server->num_waiters));
157 #endif
158
159                         seq_puts(m, "\nMIDs:\n");
160
161                         spin_lock(&GlobalMid_Lock);
162                         list_for_each(tmp1, &ses->server->pending_mid_q) {
163                                 mid_entry = list_entry(tmp1, struct
164                                         mid_q_entry,
165                                         qhead);
166                                 if (mid_entry) {
167                                         seq_printf(m,
168                                                         "State: %d com: %d pid:"
169                                                         " %d tsk: %p mid %d\n",
170                                                         mid_entry->midState,
171                                                         (int)mid_entry->command,
172                                                         mid_entry->pid,
173                                                         mid_entry->tsk,
174                                                         mid_entry->mid);
175                                 }
176                         }
177                         spin_unlock(&GlobalMid_Lock);
178                 }
179
180         }
181         read_unlock(&GlobalSMBSeslock);
182         seq_putc(m, '\n');
183
184         seq_puts(m, "Shares:");
185
186         i = 0;
187         read_lock(&GlobalSMBSeslock);
188         list_for_each(tmp, &GlobalTreeConnectionList) {
189                 __u32 dev_type;
190                 i++;
191                 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
192                 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
193                 seq_printf(m, "\n%d) %s Uses: %d ", i,
194                                  tcon->treeName, atomic_read(&tcon->useCount));
195                 if (tcon->nativeFileSystem) {
196                         seq_printf(m, "Type: %s ",
197                                          tcon->nativeFileSystem);
198                 }
199                 seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x"
200                                  "\nPathComponentMax: %d Status: %d",
201                             le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
202                             le32_to_cpu(tcon->fsAttrInfo.Attributes),
203                             le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
204                             tcon->tidStatus);
205                 if (dev_type == FILE_DEVICE_DISK)
206                         seq_puts(m, " type: DISK ");
207                 else if (dev_type == FILE_DEVICE_CD_ROM)
208                         seq_puts(m, " type: CDROM ");
209                 else
210                         seq_printf(m, " type: %d ", dev_type);
211
212                 if (tcon->tidStatus == CifsNeedReconnect)
213                         seq_puts(m, "\tDISCONNECTED ");
214         }
215         read_unlock(&GlobalSMBSeslock);
216
217         seq_putc(m, '\n');
218
219         /* BB add code to dump additional info such as TCP session info now */
220         return 0;
221 }
222
223 static int cifs_debug_data_proc_open(struct inode *inode, struct file *file)
224 {
225         return single_open(file, cifs_debug_data_proc_show, NULL);
226 }
227
228 static const struct file_operations cifs_debug_data_proc_fops = {
229         .owner          = THIS_MODULE,
230         .open           = cifs_debug_data_proc_open,
231         .read           = seq_read,
232         .llseek         = seq_lseek,
233         .release        = single_release,
234 };
235
236 #ifdef CONFIG_CIFS_STATS
237 static ssize_t cifs_stats_proc_write(struct file *file,
238                 const char __user *buffer, size_t count, loff_t *ppos)
239 {
240         char c;
241         int rc;
242         struct list_head *tmp;
243         struct cifsTconInfo *tcon;
244
245         rc = get_user(c, buffer);
246         if (rc)
247                 return rc;
248
249         if (c == '1' || c == 'y' || c == 'Y' || c == '0') {
250                 read_lock(&GlobalSMBSeslock);
251 #ifdef CONFIG_CIFS_STATS2
252                 atomic_set(&totBufAllocCount, 0);
253                 atomic_set(&totSmBufAllocCount, 0);
254 #endif /* CONFIG_CIFS_STATS2 */
255                 list_for_each(tmp, &GlobalTreeConnectionList) {
256                         tcon = list_entry(tmp, struct cifsTconInfo,
257                                         cifsConnectionList);
258                         atomic_set(&tcon->num_smbs_sent, 0);
259                         atomic_set(&tcon->num_writes, 0);
260                         atomic_set(&tcon->num_reads, 0);
261                         atomic_set(&tcon->num_oplock_brks, 0);
262                         atomic_set(&tcon->num_opens, 0);
263                         atomic_set(&tcon->num_closes, 0);
264                         atomic_set(&tcon->num_deletes, 0);
265                         atomic_set(&tcon->num_mkdirs, 0);
266                         atomic_set(&tcon->num_rmdirs, 0);
267                         atomic_set(&tcon->num_renames, 0);
268                         atomic_set(&tcon->num_t2renames, 0);
269                         atomic_set(&tcon->num_ffirst, 0);
270                         atomic_set(&tcon->num_fnext, 0);
271                         atomic_set(&tcon->num_fclose, 0);
272                         atomic_set(&tcon->num_hardlinks, 0);
273                         atomic_set(&tcon->num_symlinks, 0);
274                         atomic_set(&tcon->num_locks, 0);
275                 }
276                 read_unlock(&GlobalSMBSeslock);
277         }
278
279         return count;
280 }
281
282 static int cifs_stats_proc_show(struct seq_file *m, void *v)
283 {
284         int i;
285         struct list_head *tmp;
286         struct cifsTconInfo *tcon;
287
288         seq_printf(m,
289                         "Resources in use\nCIFS Session: %d\n",
290                         sesInfoAllocCount.counter);
291         seq_printf(m, "Share (unique mount targets): %d\n",
292                         tconInfoAllocCount.counter);
293         seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
294                         bufAllocCount.counter,
295                         cifs_min_rcv + tcpSesAllocCount.counter);
296         seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
297                         smBufAllocCount.counter, cifs_min_small);
298 #ifdef CONFIG_CIFS_STATS2
299         seq_printf(m, "Total Large %d Small %d Allocations\n",
300                                 atomic_read(&totBufAllocCount),
301                                 atomic_read(&totSmBufAllocCount));
302 #endif /* CONFIG_CIFS_STATS2 */
303
304         seq_printf(m, "Operations (MIDs): %d\n", midCount.counter);
305         seq_printf(m,
306                 "\n%d session %d share reconnects\n",
307                 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
308
309         seq_printf(m,
310                 "Total vfs operations: %d maximum at one time: %d\n",
311                 GlobalCurrentXid, GlobalMaxActiveXid);
312
313         i = 0;
314         read_lock(&GlobalSMBSeslock);
315         list_for_each(tmp, &GlobalTreeConnectionList) {
316                 i++;
317                 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
318                 seq_printf(m, "\n%d) %s", i, tcon->treeName);
319                 if (tcon->tidStatus == CifsNeedReconnect)
320                         seq_puts(m, "\tDISCONNECTED ");
321                 seq_printf(m, "\nSMBs: %d Oplock Breaks: %d",
322                         atomic_read(&tcon->num_smbs_sent),
323                         atomic_read(&tcon->num_oplock_brks));
324                 seq_printf(m, "\nReads:  %d Bytes: %lld",
325                         atomic_read(&tcon->num_reads),
326                         (long long)(tcon->bytes_read));
327                 seq_printf(m, "\nWrites: %d Bytes: %lld",
328                         atomic_read(&tcon->num_writes),
329                         (long long)(tcon->bytes_written));
330                 seq_printf(m,
331                         "\nLocks: %d HardLinks: %d Symlinks: %d",
332                         atomic_read(&tcon->num_locks),
333                         atomic_read(&tcon->num_hardlinks),
334                         atomic_read(&tcon->num_symlinks));
335
336                 seq_printf(m, "\nOpens: %d Closes: %d Deletes: %d",
337                         atomic_read(&tcon->num_opens),
338                         atomic_read(&tcon->num_closes),
339                         atomic_read(&tcon->num_deletes));
340                 seq_printf(m, "\nMkdirs: %d Rmdirs: %d",
341                         atomic_read(&tcon->num_mkdirs),
342                         atomic_read(&tcon->num_rmdirs));
343                 seq_printf(m, "\nRenames: %d T2 Renames %d",
344                         atomic_read(&tcon->num_renames),
345                         atomic_read(&tcon->num_t2renames));
346                 seq_printf(m, "\nFindFirst: %d FNext %d FClose %d",
347                         atomic_read(&tcon->num_ffirst),
348                         atomic_read(&tcon->num_fnext),
349                         atomic_read(&tcon->num_fclose));
350         }
351         read_unlock(&GlobalSMBSeslock);
352
353         seq_putc(m, '\n');
354         return 0;
355 }
356
357 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
358 {
359         return single_open(file, cifs_stats_proc_show, NULL);
360 }
361
362 static const struct file_operations cifs_stats_proc_fops = {
363         .owner          = THIS_MODULE,
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 /* STATS */
371
372 static struct proc_dir_entry *proc_fs_cifs;
373 static const struct file_operations cifsFYI_proc_fops;
374 static const struct file_operations cifs_oplock_proc_fops;
375 static const struct file_operations cifs_lookup_cache_proc_fops;
376 static const struct file_operations traceSMB_proc_fops;
377 static const struct file_operations cifs_multiuser_mount_proc_fops;
378 static const struct file_operations cifs_security_flags_proc_fops;
379 static const struct file_operations cifs_experimental_proc_fops;
380 static const struct file_operations cifs_linux_ext_proc_fops;
381
382 void
383 cifs_proc_init(void)
384 {
385         proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
386         if (proc_fs_cifs == NULL)
387                 return;
388
389         proc_fs_cifs->owner = THIS_MODULE;
390         proc_create("DebugData", 0, proc_fs_cifs, &cifs_debug_data_proc_fops);
391
392 #ifdef CONFIG_CIFS_STATS
393         proc_create("Stats", 0, proc_fs_cifs, &cifs_stats_proc_fops);
394 #endif /* STATS */
395         proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
396         proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
397         proc_create("OplockEnabled", 0, proc_fs_cifs, &cifs_oplock_proc_fops);
398         proc_create("Experimental", 0, proc_fs_cifs,
399                     &cifs_experimental_proc_fops);
400         proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
401                     &cifs_linux_ext_proc_fops);
402         proc_create("MultiuserMount", 0, proc_fs_cifs,
403                     &cifs_multiuser_mount_proc_fops);
404         proc_create("SecurityFlags", 0, proc_fs_cifs,
405                     &cifs_security_flags_proc_fops);
406         proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
407                     &cifs_lookup_cache_proc_fops);
408 }
409
410 void
411 cifs_proc_clean(void)
412 {
413         if (proc_fs_cifs == NULL)
414                 return;
415
416         remove_proc_entry("DebugData", proc_fs_cifs);
417         remove_proc_entry("cifsFYI", proc_fs_cifs);
418         remove_proc_entry("traceSMB", proc_fs_cifs);
419 #ifdef CONFIG_CIFS_STATS
420         remove_proc_entry("Stats", proc_fs_cifs);
421 #endif
422         remove_proc_entry("MultiuserMount", proc_fs_cifs);
423         remove_proc_entry("OplockEnabled", proc_fs_cifs);
424         remove_proc_entry("SecurityFlags", proc_fs_cifs);
425         remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
426         remove_proc_entry("Experimental", proc_fs_cifs);
427         remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
428         remove_proc_entry("fs/cifs", NULL);
429 }
430
431 static int cifsFYI_proc_show(struct seq_file *m, void *v)
432 {
433         seq_printf(m, "%d\n", cifsFYI);
434         return 0;
435 }
436
437 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
438 {
439         return single_open(file, cifsFYI_proc_show, NULL);
440 }
441
442 static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
443                 size_t count, loff_t *ppos)
444 {
445         char c;
446         int rc;
447
448         rc = get_user(c, buffer);
449         if (rc)
450                 return rc;
451         if (c == '0' || c == 'n' || c == 'N')
452                 cifsFYI = 0;
453         else if (c == '1' || c == 'y' || c == 'Y')
454                 cifsFYI = 1;
455         else if ((c > '1') && (c <= '9'))
456                 cifsFYI = (int) (c - '0'); /* see cifs_debug.h for meanings */
457
458         return count;
459 }
460
461 static const struct file_operations cifsFYI_proc_fops = {
462         .owner          = THIS_MODULE,
463         .open           = cifsFYI_proc_open,
464         .read           = seq_read,
465         .llseek         = seq_lseek,
466         .release        = single_release,
467         .write          = cifsFYI_proc_write,
468 };
469
470 static int cifs_oplock_proc_show(struct seq_file *m, void *v)
471 {
472         seq_printf(m, "%d\n", oplockEnabled);
473         return 0;
474 }
475
476 static int cifs_oplock_proc_open(struct inode *inode, struct file *file)
477 {
478         return single_open(file, cifs_oplock_proc_show, NULL);
479 }
480
481 static ssize_t cifs_oplock_proc_write(struct file *file,
482                 const char __user *buffer, size_t count, loff_t *ppos)
483 {
484         char c;
485         int rc;
486
487         rc = get_user(c, buffer);
488         if (rc)
489                 return rc;
490         if (c == '0' || c == 'n' || c == 'N')
491                 oplockEnabled = 0;
492         else if (c == '1' || c == 'y' || c == 'Y')
493                 oplockEnabled = 1;
494
495         return count;
496 }
497
498 static const struct file_operations cifs_oplock_proc_fops = {
499         .owner          = THIS_MODULE,
500         .open           = cifs_oplock_proc_open,
501         .read           = seq_read,
502         .llseek         = seq_lseek,
503         .release        = single_release,
504         .write          = cifs_oplock_proc_write,
505 };
506
507 static int cifs_experimental_proc_show(struct seq_file *m, void *v)
508 {
509         seq_printf(m, "%d\n", experimEnabled);
510         return 0;
511 }
512
513 static int cifs_experimental_proc_open(struct inode *inode, struct file *file)
514 {
515         return single_open(file, cifs_experimental_proc_show, NULL);
516 }
517
518 static ssize_t cifs_experimental_proc_write(struct file *file,
519                 const char __user *buffer, size_t count, loff_t *ppos)
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                 experimEnabled = 0;
529         else if (c == '1' || c == 'y' || c == 'Y')
530                 experimEnabled = 1;
531         else if (c == '2')
532                 experimEnabled = 2;
533
534         return count;
535 }
536
537 static const struct file_operations cifs_experimental_proc_fops = {
538         .owner          = THIS_MODULE,
539         .open           = cifs_experimental_proc_open,
540         .read           = seq_read,
541         .llseek         = seq_lseek,
542         .release        = single_release,
543         .write          = cifs_experimental_proc_write,
544 };
545
546 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
547 {
548         seq_printf(m, "%d\n", linuxExtEnabled);
549         return 0;
550 }
551
552 static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
553 {
554         return single_open(file, cifs_linux_ext_proc_show, NULL);
555 }
556
557 static ssize_t cifs_linux_ext_proc_write(struct file *file,
558                 const char __user *buffer, size_t count, loff_t *ppos)
559 {
560         char c;
561         int rc;
562
563         rc = get_user(c, buffer);
564         if (rc)
565                 return rc;
566         if (c == '0' || c == 'n' || c == 'N')
567                 linuxExtEnabled = 0;
568         else if (c == '1' || c == 'y' || c == 'Y')
569                 linuxExtEnabled = 1;
570
571         return count;
572 }
573
574 static const struct file_operations cifs_linux_ext_proc_fops = {
575         .owner          = THIS_MODULE,
576         .open           = cifs_linux_ext_proc_open,
577         .read           = seq_read,
578         .llseek         = seq_lseek,
579         .release        = single_release,
580         .write          = cifs_linux_ext_proc_write,
581 };
582
583 static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
584 {
585         seq_printf(m, "%d\n", lookupCacheEnabled);
586         return 0;
587 }
588
589 static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
590 {
591         return single_open(file, cifs_lookup_cache_proc_show, NULL);
592 }
593
594 static ssize_t cifs_lookup_cache_proc_write(struct file *file,
595                 const char __user *buffer, size_t count, loff_t *ppos)
596 {
597         char c;
598         int rc;
599
600         rc = get_user(c, buffer);
601         if (rc)
602                 return rc;
603         if (c == '0' || c == 'n' || c == 'N')
604                 lookupCacheEnabled = 0;
605         else if (c == '1' || c == 'y' || c == 'Y')
606                 lookupCacheEnabled = 1;
607
608         return count;
609 }
610
611 static const struct file_operations cifs_lookup_cache_proc_fops = {
612         .owner          = THIS_MODULE,
613         .open           = cifs_lookup_cache_proc_open,
614         .read           = seq_read,
615         .llseek         = seq_lseek,
616         .release        = single_release,
617         .write          = cifs_lookup_cache_proc_write,
618 };
619
620 static int traceSMB_proc_show(struct seq_file *m, void *v)
621 {
622         seq_printf(m, "%d\n", traceSMB);
623         return 0;
624 }
625
626 static int traceSMB_proc_open(struct inode *inode, struct file *file)
627 {
628         return single_open(file, traceSMB_proc_show, NULL);
629 }
630
631 static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
632                 size_t count, loff_t *ppos)
633 {
634         char c;
635         int rc;
636
637         rc = get_user(c, buffer);
638         if (rc)
639                 return rc;
640         if (c == '0' || c == 'n' || c == 'N')
641                 traceSMB = 0;
642         else if (c == '1' || c == 'y' || c == 'Y')
643                 traceSMB = 1;
644
645         return count;
646 }
647
648 static const struct file_operations traceSMB_proc_fops = {
649         .owner          = THIS_MODULE,
650         .open           = traceSMB_proc_open,
651         .read           = seq_read,
652         .llseek         = seq_lseek,
653         .release        = single_release,
654         .write          = traceSMB_proc_write,
655 };
656
657 static int cifs_multiuser_mount_proc_show(struct seq_file *m, void *v)
658 {
659         seq_printf(m, "%d\n", multiuser_mount);
660         return 0;
661 }
662
663 static int cifs_multiuser_mount_proc_open(struct inode *inode, struct file *fh)
664 {
665         return single_open(fh, cifs_multiuser_mount_proc_show, NULL);
666 }
667
668 static ssize_t cifs_multiuser_mount_proc_write(struct file *file,
669                 const char __user *buffer, size_t count, loff_t *ppos)
670 {
671         char c;
672         int rc;
673
674         rc = get_user(c, buffer);
675         if (rc)
676                 return rc;
677         if (c == '0' || c == 'n' || c == 'N')
678                 multiuser_mount = 0;
679         else if (c == '1' || c == 'y' || c == 'Y')
680                 multiuser_mount = 1;
681
682         return count;
683 }
684
685 static const struct file_operations cifs_multiuser_mount_proc_fops = {
686         .owner          = THIS_MODULE,
687         .open           = cifs_multiuser_mount_proc_open,
688         .read           = seq_read,
689         .llseek         = seq_lseek,
690         .release        = single_release,
691         .write          = cifs_multiuser_mount_proc_write,
692 };
693
694 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
695 {
696         seq_printf(m, "0x%x\n", extended_security);
697         return 0;
698 }
699
700 static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
701 {
702         return single_open(file, cifs_security_flags_proc_show, NULL);
703 }
704
705 static ssize_t cifs_security_flags_proc_write(struct file *file,
706                 const char __user *buffer, size_t count, loff_t *ppos)
707 {
708         unsigned int flags;
709         char flags_string[12];
710         char c;
711
712         if ((count < 1) || (count > 11))
713                 return -EINVAL;
714
715         memset(flags_string, 0, 12);
716
717         if (copy_from_user(flags_string, buffer, count))
718                 return -EFAULT;
719
720         if (count < 3) {
721                 /* single char or single char followed by null */
722                 c = flags_string[0];
723                 if (c == '0' || c == 'n' || c == 'N') {
724                         extended_security = CIFSSEC_DEF; /* default */
725                         return count;
726                 } else if (c == '1' || c == 'y' || c == 'Y') {
727                         extended_security = CIFSSEC_MAX;
728                         return count;
729                 } else if (!isdigit(c)) {
730                         cERROR(1, ("invalid flag %c", c));
731                         return -EINVAL;
732                 }
733         }
734         /* else we have a number */
735
736         flags = simple_strtoul(flags_string, NULL, 0);
737
738         cFYI(1, ("sec flags 0x%x", flags));
739
740         if (flags <= 0)  {
741                 cERROR(1, ("invalid security flags %s", flags_string));
742                 return -EINVAL;
743         }
744
745         if (flags & ~CIFSSEC_MASK) {
746                 cERROR(1, ("attempt to set unsupported security flags 0x%x",
747                         flags & ~CIFSSEC_MASK));
748                 return -EINVAL;
749         }
750         /* flags look ok - update the global security flags for cifs module */
751         extended_security = flags;
752         if (extended_security & CIFSSEC_MUST_SIGN) {
753                 /* requiring signing implies signing is allowed */
754                 extended_security |= CIFSSEC_MAY_SIGN;
755                 cFYI(1, ("packet signing now required"));
756         } else if ((extended_security & CIFSSEC_MAY_SIGN) == 0) {
757                 cFYI(1, ("packet signing disabled"));
758         }
759         /* BB should we turn on MAY flags for other MUST options? */
760         return count;
761 }
762
763 static const struct file_operations cifs_security_flags_proc_fops = {
764         .owner          = THIS_MODULE,
765         .open           = cifs_security_flags_proc_open,
766         .read           = seq_read,
767         .llseek         = seq_lseek,
768         .release        = single_release,
769         .write          = cifs_security_flags_proc_write,
770 };
771 #else
772 inline void cifs_proc_init(void)
773 {
774 }
775
776 inline void cifs_proc_clean(void)
777 {
778 }
779 #endif /* PROC_FS */