linux/fs/cifs/cifs_debug.c
<<
>>
Prefs
   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
  34void
  35cifs_dump_mem(char *label, void *data, int length)
  36{
  37        int i, j;
  38        int *intptr = data;
  39        char *charptr = data;
  40        char buf[10], line[80];
  41
  42        printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n",
  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
  60void cifs_dump_detail(void *buf)
  61{
  62#ifdef CONFIG_CIFS_DEBUG2
  63        struct smb_hdr *smb = (struct smb_hdr *)buf;
  64
  65        cERROR(1, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d",
  66                  smb->Command, smb->Status.CifsError,
  67                  smb->Flags, smb->Flags2, smb->Mid, smb->Pid);
  68        cERROR(1, "smb buf %p len %u", smb, smbCalcSize(smb));
  69#endif /* CONFIG_CIFS_DEBUG2 */
  70}
  71
  72void cifs_dump_mids(struct TCP_Server_Info *server)
  73{
  74#ifdef CONFIG_CIFS_DEBUG2
  75        struct list_head *tmp;
  76        struct mid_q_entry *mid_entry;
  77
  78        if (server == NULL)
  79                return;
  80
  81        cERROR(1, "Dump pending requests:");
  82        spin_lock(&GlobalMid_Lock);
  83        list_for_each(tmp, &server->pending_mid_q) {
  84                mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
  85                cERROR(1, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu",
  86                        mid_entry->mid_state,
  87                        le16_to_cpu(mid_entry->command),
  88                        mid_entry->pid,
  89                        mid_entry->callback_data,
  90                        mid_entry->mid);
  91#ifdef CONFIG_CIFS_STATS2
  92                cERROR(1, "IsLarge: %d buf: %p time rcv: %ld now: %ld",
  93                        mid_entry->large_buf,
  94                        mid_entry->resp_buf,
  95                        mid_entry->when_received,
  96                        jiffies);
  97#endif /* STATS2 */
  98                cERROR(1, "IsMult: %d IsEnd: %d", mid_entry->multiRsp,
  99                          mid_entry->multiEnd);
 100                if (mid_entry->resp_buf) {
 101                        cifs_dump_detail(mid_entry->resp_buf);
 102                        cifs_dump_mem("existing buf: ",
 103                                mid_entry->resp_buf, 62);
 104                }
 105        }
 106        spin_unlock(&GlobalMid_Lock);
 107#endif /* CONFIG_CIFS_DEBUG2 */
 108}
 109
 110#ifdef CONFIG_PROC_FS
 111static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 112{
 113        struct list_head *tmp1, *tmp2, *tmp3;
 114        struct mid_q_entry *mid_entry;
 115        struct TCP_Server_Info *server;
 116        struct cifs_ses *ses;
 117        struct cifs_tcon *tcon;
 118        int i, j;
 119        __u32 dev_type;
 120
 121        seq_puts(m,
 122                    "Display Internal CIFS Data Structures for Debugging\n"
 123                    "---------------------------------------------------\n");
 124        seq_printf(m, "CIFS Version %s\n", CIFS_VERSION);
 125        seq_printf(m, "Features:");
 126#ifdef CONFIG_CIFS_DFS_UPCALL
 127        seq_printf(m, " dfs");
 128#endif
 129#ifdef CONFIG_CIFS_FSCACHE
 130        seq_printf(m, " fscache");
 131#endif
 132#ifdef CONFIG_CIFS_WEAK_PW_HASH
 133        seq_printf(m, " lanman");
 134#endif
 135#ifdef CONFIG_CIFS_POSIX
 136        seq_printf(m, " posix");
 137#endif
 138#ifdef CONFIG_CIFS_UPCALL
 139        seq_printf(m, " spnego");
 140#endif
 141#ifdef CONFIG_CIFS_XATTR
 142        seq_printf(m, " xattr");
 143#endif
 144#ifdef CONFIG_CIFS_ACL
 145        seq_printf(m, " acl");
 146#endif
 147        seq_putc(m, '\n');
 148        seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid);
 149        seq_printf(m, "Servers:");
 150
 151        i = 0;
 152        spin_lock(&cifs_tcp_ses_lock);
 153        list_for_each(tmp1, &cifs_tcp_ses_list) {
 154                server = list_entry(tmp1, struct TCP_Server_Info,
 155                                    tcp_ses_list);
 156                i++;
 157                list_for_each(tmp2, &server->smb_ses_list) {
 158                        ses = list_entry(tmp2, struct cifs_ses,
 159                                         smb_ses_list);
 160                        if ((ses->serverDomain == NULL) ||
 161                                (ses->serverOS == NULL) ||
 162                                (ses->serverNOS == NULL)) {
 163                                seq_printf(m, "\n%d) entry for %s not fully "
 164                                           "displayed\n\t", i, ses->serverName);
 165                        } else {
 166                                seq_printf(m,
 167                                    "\n%d) Name: %s  Domain: %s Uses: %d OS:"
 168                                    " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB"
 169                                    " session status: %d\t",
 170                                i, ses->serverName, ses->serverDomain,
 171                                ses->ses_count, ses->serverOS, ses->serverNOS,
 172                                ses->capabilities, ses->status);
 173                        }
 174                        seq_printf(m, "TCP status: %d\n\tLocal Users To "
 175                                   "Server: %d SecMode: 0x%x Req On Wire: %d",
 176                                   server->tcpStatus, server->srv_count,
 177                                   server->sec_mode, in_flight(server));
 178
 179#ifdef CONFIG_CIFS_STATS2
 180                        seq_printf(m, " In Send: %d In MaxReq Wait: %d",
 181                                atomic_read(&server->in_send),
 182                                atomic_read(&server->num_waiters));
 183#endif
 184
 185                        seq_puts(m, "\n\tShares:");
 186                        j = 0;
 187                        list_for_each(tmp3, &ses->tcon_list) {
 188                                tcon = list_entry(tmp3, struct cifs_tcon,
 189                                                  tcon_list);
 190                                ++j;
 191                                dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
 192                                seq_printf(m, "\n\t%d) %s Mounts: %d ", j,
 193                                           tcon->treeName, tcon->tc_count);
 194                                if (tcon->nativeFileSystem) {
 195                                        seq_printf(m, "Type: %s ",
 196                                                   tcon->nativeFileSystem);
 197                                }
 198                                seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x"
 199                                        "\nPathComponentMax: %d Status: 0x%d",
 200                                        le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
 201                                        le32_to_cpu(tcon->fsAttrInfo.Attributes),
 202                                        le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
 203                                        tcon->tidStatus);
 204                                if (dev_type == FILE_DEVICE_DISK)
 205                                        seq_puts(m, " type: DISK ");
 206                                else if (dev_type == FILE_DEVICE_CD_ROM)
 207                                        seq_puts(m, " type: CDROM ");
 208                                else
 209                                        seq_printf(m, " type: %d ", dev_type);
 210
 211                                if (tcon->need_reconnect)
 212                                        seq_puts(m, "\tDISCONNECTED ");
 213                                seq_putc(m, '\n');
 214                        }
 215
 216                        seq_puts(m, "\n\tMIDs:\n");
 217
 218                        spin_lock(&GlobalMid_Lock);
 219                        list_for_each(tmp3, &server->pending_mid_q) {
 220                                mid_entry = list_entry(tmp3, struct mid_q_entry,
 221                                        qhead);
 222                                seq_printf(m, "\tState: %d com: %d pid:"
 223                                              " %d cbdata: %p mid %llu\n",
 224                                              mid_entry->mid_state,
 225                                              le16_to_cpu(mid_entry->command),
 226                                              mid_entry->pid,
 227                                              mid_entry->callback_data,
 228                                              mid_entry->mid);
 229                        }
 230                        spin_unlock(&GlobalMid_Lock);
 231                }
 232        }
 233        spin_unlock(&cifs_tcp_ses_lock);
 234        seq_putc(m, '\n');
 235
 236        /* BB add code to dump additional info such as TCP session info now */
 237        return 0;
 238}
 239
 240static int cifs_debug_data_proc_open(struct inode *inode, struct file *file)
 241{
 242        return single_open(file, cifs_debug_data_proc_show, NULL);
 243}
 244
 245static const struct file_operations cifs_debug_data_proc_fops = {
 246        .owner          = THIS_MODULE,
 247        .open           = cifs_debug_data_proc_open,
 248        .read           = seq_read,
 249        .llseek         = seq_lseek,
 250        .release        = single_release,
 251};
 252
 253#ifdef CONFIG_CIFS_STATS
 254static ssize_t cifs_stats_proc_write(struct file *file,
 255                const char __user *buffer, size_t count, loff_t *ppos)
 256{
 257        char c;
 258        int rc;
 259        struct list_head *tmp1, *tmp2, *tmp3;
 260        struct TCP_Server_Info *server;
 261        struct cifs_ses *ses;
 262        struct cifs_tcon *tcon;
 263
 264        rc = get_user(c, buffer);
 265        if (rc)
 266                return rc;
 267
 268        if (c == '1' || c == 'y' || c == 'Y' || c == '0') {
 269#ifdef CONFIG_CIFS_STATS2
 270                atomic_set(&totBufAllocCount, 0);
 271                atomic_set(&totSmBufAllocCount, 0);
 272#endif /* CONFIG_CIFS_STATS2 */
 273                spin_lock(&cifs_tcp_ses_lock);
 274                list_for_each(tmp1, &cifs_tcp_ses_list) {
 275                        server = list_entry(tmp1, struct TCP_Server_Info,
 276                                            tcp_ses_list);
 277                        list_for_each(tmp2, &server->smb_ses_list) {
 278                                ses = list_entry(tmp2, struct cifs_ses,
 279                                                 smb_ses_list);
 280                                list_for_each(tmp3, &ses->tcon_list) {
 281                                        tcon = list_entry(tmp3,
 282                                                          struct cifs_tcon,
 283                                                          tcon_list);
 284                                        atomic_set(&tcon->num_smbs_sent, 0);
 285                                        if (server->ops->clear_stats)
 286                                                server->ops->clear_stats(tcon);
 287                                }
 288                        }
 289                }
 290                spin_unlock(&cifs_tcp_ses_lock);
 291        }
 292
 293        return count;
 294}
 295
 296static int cifs_stats_proc_show(struct seq_file *m, void *v)
 297{
 298        int i;
 299        struct list_head *tmp1, *tmp2, *tmp3;
 300        struct TCP_Server_Info *server;
 301        struct cifs_ses *ses;
 302        struct cifs_tcon *tcon;
 303
 304        seq_printf(m,
 305                        "Resources in use\nCIFS Session: %d\n",
 306                        sesInfoAllocCount.counter);
 307        seq_printf(m, "Share (unique mount targets): %d\n",
 308                        tconInfoAllocCount.counter);
 309        seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
 310                        bufAllocCount.counter,
 311                        cifs_min_rcv + tcpSesAllocCount.counter);
 312        seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
 313                        smBufAllocCount.counter, cifs_min_small);
 314#ifdef CONFIG_CIFS_STATS2
 315        seq_printf(m, "Total Large %d Small %d Allocations\n",
 316                                atomic_read(&totBufAllocCount),
 317                                atomic_read(&totSmBufAllocCount));
 318#endif /* CONFIG_CIFS_STATS2 */
 319
 320        seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount));
 321        seq_printf(m,
 322                "\n%d session %d share reconnects\n",
 323                tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
 324
 325        seq_printf(m,
 326                "Total vfs operations: %d maximum at one time: %d\n",
 327                GlobalCurrentXid, GlobalMaxActiveXid);
 328
 329        i = 0;
 330        spin_lock(&cifs_tcp_ses_lock);
 331        list_for_each(tmp1, &cifs_tcp_ses_list) {
 332                server = list_entry(tmp1, struct TCP_Server_Info,
 333                                    tcp_ses_list);
 334                list_for_each(tmp2, &server->smb_ses_list) {
 335                        ses = list_entry(tmp2, struct cifs_ses,
 336                                         smb_ses_list);
 337                        list_for_each(tmp3, &ses->tcon_list) {
 338                                tcon = list_entry(tmp3,
 339                                                  struct cifs_tcon,
 340                                                  tcon_list);
 341                                i++;
 342                                seq_printf(m, "\n%d) %s", i, tcon->treeName);
 343                                if (tcon->need_reconnect)
 344                                        seq_puts(m, "\tDISCONNECTED ");
 345                                seq_printf(m, "\nSMBs: %d",
 346                                           atomic_read(&tcon->num_smbs_sent));
 347                                if (server->ops->print_stats)
 348                                        server->ops->print_stats(m, tcon);
 349                        }
 350                }
 351        }
 352        spin_unlock(&cifs_tcp_ses_lock);
 353
 354        seq_putc(m, '\n');
 355        return 0;
 356}
 357
 358static int cifs_stats_proc_open(struct inode *inode, struct file *file)
 359{
 360        return single_open(file, cifs_stats_proc_show, NULL);
 361}
 362
 363static const struct file_operations cifs_stats_proc_fops = {
 364        .owner          = THIS_MODULE,
 365        .open           = cifs_stats_proc_open,
 366        .read           = seq_read,
 367        .llseek         = seq_lseek,
 368        .release        = single_release,
 369        .write          = cifs_stats_proc_write,
 370};
 371#endif /* STATS */
 372
 373static struct proc_dir_entry *proc_fs_cifs;
 374static const struct file_operations cifsFYI_proc_fops;
 375static const struct file_operations cifs_lookup_cache_proc_fops;
 376static const struct file_operations traceSMB_proc_fops;
 377static const struct file_operations cifs_security_flags_proc_fops;
 378static const struct file_operations cifs_linux_ext_proc_fops;
 379
 380void
 381cifs_proc_init(void)
 382{
 383        proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
 384        if (proc_fs_cifs == NULL)
 385                return;
 386
 387        proc_create("DebugData", 0, proc_fs_cifs, &cifs_debug_data_proc_fops);
 388
 389#ifdef CONFIG_CIFS_STATS
 390        proc_create("Stats", 0, proc_fs_cifs, &cifs_stats_proc_fops);
 391#endif /* STATS */
 392        proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
 393        proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
 394        proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
 395                    &cifs_linux_ext_proc_fops);
 396        proc_create("SecurityFlags", 0, proc_fs_cifs,
 397                    &cifs_security_flags_proc_fops);
 398        proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
 399                    &cifs_lookup_cache_proc_fops);
 400}
 401
 402void
 403cifs_proc_clean(void)
 404{
 405        if (proc_fs_cifs == NULL)
 406                return;
 407
 408        remove_proc_entry("DebugData", proc_fs_cifs);
 409        remove_proc_entry("cifsFYI", proc_fs_cifs);
 410        remove_proc_entry("traceSMB", proc_fs_cifs);
 411#ifdef CONFIG_CIFS_STATS
 412        remove_proc_entry("Stats", proc_fs_cifs);
 413#endif
 414        remove_proc_entry("SecurityFlags", proc_fs_cifs);
 415        remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
 416        remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
 417        remove_proc_entry("fs/cifs", NULL);
 418}
 419
 420static int cifsFYI_proc_show(struct seq_file *m, void *v)
 421{
 422        seq_printf(m, "%d\n", cifsFYI);
 423        return 0;
 424}
 425
 426static int cifsFYI_proc_open(struct inode *inode, struct file *file)
 427{
 428        return single_open(file, cifsFYI_proc_show, NULL);
 429}
 430
 431static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
 432                size_t count, loff_t *ppos)
 433{
 434        char c;
 435        int rc;
 436
 437        rc = get_user(c, buffer);
 438        if (rc)
 439                return rc;
 440        if (c == '0' || c == 'n' || c == 'N')
 441                cifsFYI = 0;
 442        else if (c == '1' || c == 'y' || c == 'Y')
 443                cifsFYI = 1;
 444        else if ((c > '1') && (c <= '9'))
 445                cifsFYI = (int) (c - '0'); /* see cifs_debug.h for meanings */
 446
 447        return count;
 448}
 449
 450static const struct file_operations cifsFYI_proc_fops = {
 451        .owner          = THIS_MODULE,
 452        .open           = cifsFYI_proc_open,
 453        .read           = seq_read,
 454        .llseek         = seq_lseek,
 455        .release        = single_release,
 456        .write          = cifsFYI_proc_write,
 457};
 458
 459static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
 460{
 461        seq_printf(m, "%d\n", linuxExtEnabled);
 462        return 0;
 463}
 464
 465static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
 466{
 467        return single_open(file, cifs_linux_ext_proc_show, NULL);
 468}
 469
 470static ssize_t cifs_linux_ext_proc_write(struct file *file,
 471                const char __user *buffer, size_t count, loff_t *ppos)
 472{
 473        char c;
 474        int rc;
 475
 476        rc = get_user(c, buffer);
 477        if (rc)
 478                return rc;
 479        if (c == '0' || c == 'n' || c == 'N')
 480                linuxExtEnabled = 0;
 481        else if (c == '1' || c == 'y' || c == 'Y')
 482                linuxExtEnabled = 1;
 483
 484        return count;
 485}
 486
 487static const struct file_operations cifs_linux_ext_proc_fops = {
 488        .owner          = THIS_MODULE,
 489        .open           = cifs_linux_ext_proc_open,
 490        .read           = seq_read,
 491        .llseek         = seq_lseek,
 492        .release        = single_release,
 493        .write          = cifs_linux_ext_proc_write,
 494};
 495
 496static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
 497{
 498        seq_printf(m, "%d\n", lookupCacheEnabled);
 499        return 0;
 500}
 501
 502static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
 503{
 504        return single_open(file, cifs_lookup_cache_proc_show, NULL);
 505}
 506
 507static ssize_t cifs_lookup_cache_proc_write(struct file *file,
 508                const char __user *buffer, size_t count, loff_t *ppos)
 509{
 510        char c;
 511        int rc;
 512
 513        rc = get_user(c, buffer);
 514        if (rc)
 515                return rc;
 516        if (c == '0' || c == 'n' || c == 'N')
 517                lookupCacheEnabled = 0;
 518        else if (c == '1' || c == 'y' || c == 'Y')
 519                lookupCacheEnabled = 1;
 520
 521        return count;
 522}
 523
 524static const struct file_operations cifs_lookup_cache_proc_fops = {
 525        .owner          = THIS_MODULE,
 526        .open           = cifs_lookup_cache_proc_open,
 527        .read           = seq_read,
 528        .llseek         = seq_lseek,
 529        .release        = single_release,
 530        .write          = cifs_lookup_cache_proc_write,
 531};
 532
 533static int traceSMB_proc_show(struct seq_file *m, void *v)
 534{
 535        seq_printf(m, "%d\n", traceSMB);
 536        return 0;
 537}
 538
 539static int traceSMB_proc_open(struct inode *inode, struct file *file)
 540{
 541        return single_open(file, traceSMB_proc_show, NULL);
 542}
 543
 544static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
 545                size_t count, loff_t *ppos)
 546{
 547        char c;
 548        int rc;
 549
 550        rc = get_user(c, buffer);
 551        if (rc)
 552                return rc;
 553        if (c == '0' || c == 'n' || c == 'N')
 554                traceSMB = 0;
 555        else if (c == '1' || c == 'y' || c == 'Y')
 556                traceSMB = 1;
 557
 558        return count;
 559}
 560
 561static const struct file_operations traceSMB_proc_fops = {
 562        .owner          = THIS_MODULE,
 563        .open           = traceSMB_proc_open,
 564        .read           = seq_read,
 565        .llseek         = seq_lseek,
 566        .release        = single_release,
 567        .write          = traceSMB_proc_write,
 568};
 569
 570static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
 571{
 572        seq_printf(m, "0x%x\n", global_secflags);
 573        return 0;
 574}
 575
 576static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
 577{
 578        return single_open(file, cifs_security_flags_proc_show, NULL);
 579}
 580
 581static ssize_t cifs_security_flags_proc_write(struct file *file,
 582                const char __user *buffer, size_t count, loff_t *ppos)
 583{
 584        unsigned int flags;
 585        char flags_string[12];
 586        char c;
 587
 588        if ((count < 1) || (count > 11))
 589                return -EINVAL;
 590
 591        memset(flags_string, 0, 12);
 592
 593        if (copy_from_user(flags_string, buffer, count))
 594                return -EFAULT;
 595
 596        if (count < 3) {
 597                /* single char or single char followed by null */
 598                c = flags_string[0];
 599                if (c == '0' || c == 'n' || c == 'N') {
 600                        global_secflags = CIFSSEC_DEF; /* default */
 601                        return count;
 602                } else if (c == '1' || c == 'y' || c == 'Y') {
 603                        global_secflags = CIFSSEC_MAX;
 604                        return count;
 605                } else if (!isdigit(c)) {
 606                        cERROR(1, "invalid flag %c", c);
 607                        return -EINVAL;
 608                }
 609        }
 610        /* else we have a number */
 611
 612        flags = simple_strtoul(flags_string, NULL, 0);
 613
 614        cFYI(1, "sec flags 0x%x", flags);
 615
 616        if (flags <= 0)  {
 617                cERROR(1, "invalid security flags %s", flags_string);
 618                return -EINVAL;
 619        }
 620
 621        if (flags & ~CIFSSEC_MASK) {
 622                cERROR(1, "attempt to set unsupported security flags 0x%x",
 623                        flags & ~CIFSSEC_MASK);
 624                return -EINVAL;
 625        }
 626        /* flags look ok - update the global security flags for cifs module */
 627        global_secflags = flags;
 628        if (global_secflags & CIFSSEC_MUST_SIGN) {
 629                /* requiring signing implies signing is allowed */
 630                global_secflags |= CIFSSEC_MAY_SIGN;
 631                cFYI(1, "packet signing now required");
 632        } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) {
 633                cFYI(1, "packet signing disabled");
 634        }
 635        /* BB should we turn on MAY flags for other MUST options? */
 636        return count;
 637}
 638
 639static const struct file_operations cifs_security_flags_proc_fops = {
 640        .owner          = THIS_MODULE,
 641        .open           = cifs_security_flags_proc_open,
 642        .read           = seq_read,
 643        .llseek         = seq_lseek,
 644        .release        = single_release,
 645        .write          = cifs_security_flags_proc_write,
 646};
 647#else
 648inline void cifs_proc_init(void)
 649{
 650}
 651
 652inline void cifs_proc_clean(void)
 653{
 654}
 655#endif /* PROC_FS */
 656
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.