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