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