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