GNU Linux-libre 4.9.308-gnu1
[releases.git] / fs / cifs / cifs_debug.c
1 /*
2  *   fs/cifs_debug.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2000,2005
5  *
6  *   Modified by Steve French (sfrench@us.ibm.com)
7  *
8  *   This program is free software;  you can redistribute it and/or modify
9  *   it under the terms of the GNU General Public License as published by
10  *   the Free Software Foundation; either version 2 of the License, or
11  *   (at your option) any later version.
12  *
13  *   This program is distributed in the hope that it will be useful,
14  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
16  *   the GNU General Public License for more details.
17  *
18  *   You should have received a copy of the GNU General Public License
19  *   along with this program;  if not, write to the Free Software
20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21  */
22 #include <linux/fs.h>
23 #include <linux/string.h>
24 #include <linux/ctype.h>
25 #include <linux/module.h>
26 #include <linux/proc_fs.h>
27 #include <asm/uaccess.h>
28 #include "cifspdu.h"
29 #include "cifsglob.h"
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifsfs.h"
33
34 void
35 cifs_dump_mem(char *label, void *data, int length)
36 {
37         pr_debug("%s: dump of %d bytes of data at 0x%p\n", label, length, data);
38         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 4,
39                        data, length, true);
40 }
41
42 #ifdef CONFIG_CIFS_DEBUG
43 void cifs_vfs_err(const char *fmt, ...)
44 {
45         struct va_format vaf;
46         va_list args;
47
48         va_start(args, fmt);
49
50         vaf.fmt = fmt;
51         vaf.va = &args;
52
53         pr_err_ratelimited("CIFS VFS: %pV", &vaf);
54
55         va_end(args);
56 }
57 #endif
58
59 void cifs_dump_detail(void *buf)
60 {
61 #ifdef CONFIG_CIFS_DEBUG2
62         struct smb_hdr *smb = (struct smb_hdr *)buf;
63
64         cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d\n",
65                  smb->Command, smb->Status.CifsError,
66                  smb->Flags, smb->Flags2, smb->Mid, smb->Pid);
67         cifs_dbg(VFS, "smb buf %p len %u\n", smb, smbCalcSize(smb));
68 #endif /* CONFIG_CIFS_DEBUG2 */
69 }
70
71 void cifs_dump_mids(struct TCP_Server_Info *server)
72 {
73 #ifdef CONFIG_CIFS_DEBUG2
74         struct list_head *tmp;
75         struct mid_q_entry *mid_entry;
76
77         if (server == NULL)
78                 return;
79
80         cifs_dbg(VFS, "Dump pending requests:\n");
81         spin_lock(&GlobalMid_Lock);
82         list_for_each(tmp, &server->pending_mid_q) {
83                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
84                 cifs_dbg(VFS, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu\n",
85                          mid_entry->mid_state,
86                          le16_to_cpu(mid_entry->command),
87                          mid_entry->pid,
88                          mid_entry->callback_data,
89                          mid_entry->mid);
90 #ifdef CONFIG_CIFS_STATS2
91                 cifs_dbg(VFS, "IsLarge: %d buf: %p time rcv: %ld now: %ld\n",
92                          mid_entry->large_buf,
93                          mid_entry->resp_buf,
94                          mid_entry->when_received,
95                          jiffies);
96 #endif /* STATS2 */
97                 cifs_dbg(VFS, "IsMult: %d IsEnd: %d\n",
98                          mid_entry->multiRsp, mid_entry->multiEnd);
99                 if (mid_entry->resp_buf) {
100                         cifs_dump_detail(mid_entry->resp_buf);
101                         cifs_dump_mem("existing buf: ",
102                                 mid_entry->resp_buf, 62);
103                 }
104         }
105         spin_unlock(&GlobalMid_Lock);
106 #endif /* CONFIG_CIFS_DEBUG2 */
107 }
108
109 #ifdef CONFIG_PROC_FS
110 static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
111 {
112         struct list_head *tmp1, *tmp2, *tmp3;
113         struct mid_q_entry *mid_entry;
114         struct TCP_Server_Info *server;
115         struct cifs_ses *ses;
116         struct cifs_tcon *tcon;
117         int i, j;
118         __u32 dev_type;
119
120         seq_puts(m,
121                     "Display Internal CIFS Data Structures for Debugging\n"
122                     "---------------------------------------------------\n");
123         seq_printf(m, "CIFS Version %s\n", CIFS_VERSION);
124         seq_printf(m, "Features:");
125 #ifdef CONFIG_CIFS_DFS_UPCALL
126         seq_printf(m, " DFS");
127 #endif
128 #ifdef CONFIG_CIFS_FSCACHE
129         seq_printf(m, ",FSCACHE");
130 #endif
131 #ifdef CONFIG_CIFS_SMB_DIRECT
132         seq_printf(m, ",SMB_DIRECT");
133 #endif
134 #ifdef CONFIG_CIFS_STATS2
135         seq_printf(m, ",STATS2");
136 #elif defined(CONFIG_CIFS_STATS)
137         seq_printf(m, ",STATS");
138 #endif
139 #ifdef CONFIG_CIFS_DEBUG2
140         seq_printf(m, ",DEBUG2");
141 #elif defined(CONFIG_CIFS_DEBUG)
142         seq_printf(m, ",DEBUG");
143 #endif
144 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
145         seq_printf(m, ",ALLOW_INSECURE_LEGACY");
146 #endif
147 #ifdef CONFIG_CIFS_WEAK_PW_HASH
148         seq_printf(m, ",WEAK_PW_HASH");
149 #endif
150 #ifdef CONFIG_CIFS_POSIX
151         seq_printf(m, ",CIFS_POSIX");
152 #endif
153 #ifdef CONFIG_CIFS_UPCALL
154         seq_printf(m, ",UPCALL(SPNEGO)");
155 #endif
156 #ifdef CONFIG_CIFS_XATTR
157         seq_printf(m, ",XATTR");
158 #endif
159 #ifdef CONFIG_CIFS_ACL
160         seq_printf(m, ",ACL");
161 #endif
162         seq_putc(m, '\n');
163         seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid);
164         seq_printf(m, "Servers:");
165
166         i = 0;
167         spin_lock(&cifs_tcp_ses_lock);
168         list_for_each(tmp1, &cifs_tcp_ses_list) {
169                 server = list_entry(tmp1, struct TCP_Server_Info,
170                                     tcp_ses_list);
171                 seq_printf(m, "\nNumber of credits: %d", server->credits);
172                 i++;
173                 list_for_each(tmp2, &server->smb_ses_list) {
174                         ses = list_entry(tmp2, struct cifs_ses,
175                                          smb_ses_list);
176                         if ((ses->serverDomain == NULL) ||
177                                 (ses->serverOS == NULL) ||
178                                 (ses->serverNOS == NULL)) {
179                                 seq_printf(m, "\n%d) entry for %s not fully "
180                                            "displayed\n\t", i, ses->serverName);
181                         } else {
182                                 seq_printf(m,
183                                     "\n%d) Name: %s  Domain: %s Uses: %d OS:"
184                                     " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB"
185                                     " session status: %d\t",
186                                 i, ses->serverName, ses->serverDomain,
187                                 ses->ses_count, ses->serverOS, ses->serverNOS,
188                                 ses->capabilities, ses->status);
189                         }
190                         seq_printf(m, "TCP status: %d\n\tLocal Users To "
191                                    "Server: %d SecMode: 0x%x Req On Wire: %d",
192                                    server->tcpStatus, server->srv_count,
193                                    server->sec_mode, in_flight(server));
194
195 #ifdef CONFIG_CIFS_STATS2
196                         seq_printf(m, " In Send: %d In MaxReq Wait: %d",
197                                 atomic_read(&server->in_send),
198                                 atomic_read(&server->num_waiters));
199 #endif
200
201                         seq_puts(m, "\n\tShares:");
202                         j = 0;
203                         list_for_each(tmp3, &ses->tcon_list) {
204                                 tcon = list_entry(tmp3, struct cifs_tcon,
205                                                   tcon_list);
206                                 ++j;
207                                 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
208                                 seq_printf(m, "\n\t%d) %s Mounts: %d ", j,
209                                            tcon->treeName, tcon->tc_count);
210                                 if (tcon->nativeFileSystem) {
211                                         seq_printf(m, "Type: %s ",
212                                                    tcon->nativeFileSystem);
213                                 }
214                                 seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x"
215                                         "\n\tPathComponentMax: %d Status: %d",
216                                         le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
217                                         le32_to_cpu(tcon->fsAttrInfo.Attributes),
218                                         le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
219                                         tcon->tidStatus);
220                                 if (dev_type == FILE_DEVICE_DISK)
221                                         seq_puts(m, " type: DISK ");
222                                 else if (dev_type == FILE_DEVICE_CD_ROM)
223                                         seq_puts(m, " type: CDROM ");
224                                 else
225                                         seq_printf(m, " type: %d ", dev_type);
226                                 if (server->ops->dump_share_caps)
227                                         server->ops->dump_share_caps(m, tcon);
228
229                                 if (tcon->need_reconnect)
230                                         seq_puts(m, "\tDISCONNECTED ");
231                                 seq_putc(m, '\n');
232                         }
233
234                         seq_puts(m, "\n\tMIDs:\n");
235
236                         spin_lock(&GlobalMid_Lock);
237                         list_for_each(tmp3, &server->pending_mid_q) {
238                                 mid_entry = list_entry(tmp3, struct mid_q_entry,
239                                         qhead);
240                                 seq_printf(m, "\tState: %d com: %d pid:"
241                                               " %d cbdata: %p mid %llu\n",
242                                               mid_entry->mid_state,
243                                               le16_to_cpu(mid_entry->command),
244                                               mid_entry->pid,
245                                               mid_entry->callback_data,
246                                               mid_entry->mid);
247                         }
248                         spin_unlock(&GlobalMid_Lock);
249                 }
250         }
251         spin_unlock(&cifs_tcp_ses_lock);
252         seq_putc(m, '\n');
253
254         /* BB add code to dump additional info such as TCP session info now */
255         return 0;
256 }
257
258 static int cifs_debug_data_proc_open(struct inode *inode, struct file *file)
259 {
260         return single_open(file, cifs_debug_data_proc_show, NULL);
261 }
262
263 static const struct file_operations cifs_debug_data_proc_fops = {
264         .open           = cifs_debug_data_proc_open,
265         .read           = seq_read,
266         .llseek         = seq_lseek,
267         .release        = single_release,
268 };
269
270 #ifdef CONFIG_CIFS_STATS
271 static ssize_t cifs_stats_proc_write(struct file *file,
272                 const char __user *buffer, size_t count, loff_t *ppos)
273 {
274         bool bv;
275         int rc;
276         struct list_head *tmp1, *tmp2, *tmp3;
277         struct TCP_Server_Info *server;
278         struct cifs_ses *ses;
279         struct cifs_tcon *tcon;
280
281         rc = kstrtobool_from_user(buffer, count, &bv);
282         if (rc == 0) {
283 #ifdef CONFIG_CIFS_STATS2
284                 atomic_set(&totBufAllocCount, 0);
285                 atomic_set(&totSmBufAllocCount, 0);
286 #endif /* CONFIG_CIFS_STATS2 */
287                 atomic_set(&tcpSesReconnectCount, 0);
288                 atomic_set(&tconInfoReconnectCount, 0);
289
290                 spin_lock(&GlobalMid_Lock);
291                 GlobalMaxActiveXid = 0;
292                 GlobalCurrentXid = 0;
293                 spin_unlock(&GlobalMid_Lock);
294                 spin_lock(&cifs_tcp_ses_lock);
295                 list_for_each(tmp1, &cifs_tcp_ses_list) {
296                         server = list_entry(tmp1, struct TCP_Server_Info,
297                                             tcp_ses_list);
298                         list_for_each(tmp2, &server->smb_ses_list) {
299                                 ses = list_entry(tmp2, struct cifs_ses,
300                                                  smb_ses_list);
301                                 list_for_each(tmp3, &ses->tcon_list) {
302                                         tcon = list_entry(tmp3,
303                                                           struct cifs_tcon,
304                                                           tcon_list);
305                                         atomic_set(&tcon->num_smbs_sent, 0);
306                                         spin_lock(&tcon->stat_lock);
307                                         tcon->bytes_read = 0;
308                                         tcon->bytes_written = 0;
309                                         spin_unlock(&tcon->stat_lock);
310                                         if (server->ops->clear_stats)
311                                                 server->ops->clear_stats(tcon);
312                                 }
313                         }
314                 }
315                 spin_unlock(&cifs_tcp_ses_lock);
316         } else {
317                 return rc;
318         }
319
320         return count;
321 }
322
323 static int cifs_stats_proc_show(struct seq_file *m, void *v)
324 {
325         int i;
326         struct list_head *tmp1, *tmp2, *tmp3;
327         struct TCP_Server_Info *server;
328         struct cifs_ses *ses;
329         struct cifs_tcon *tcon;
330
331         seq_printf(m,
332                         "Resources in use\nCIFS Session: %d\n",
333                         sesInfoAllocCount.counter);
334         seq_printf(m, "Share (unique mount targets): %d\n",
335                         tconInfoAllocCount.counter);
336         seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
337                         bufAllocCount.counter,
338                         cifs_min_rcv + tcpSesAllocCount.counter);
339         seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
340                         smBufAllocCount.counter, cifs_min_small);
341 #ifdef CONFIG_CIFS_STATS2
342         seq_printf(m, "Total Large %d Small %d Allocations\n",
343                                 atomic_read(&totBufAllocCount),
344                                 atomic_read(&totSmBufAllocCount));
345 #endif /* CONFIG_CIFS_STATS2 */
346
347         seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount));
348         seq_printf(m,
349                 "\n%d session %d share reconnects\n",
350                 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
351
352         seq_printf(m,
353                 "Total vfs operations: %d maximum at one time: %d\n",
354                 GlobalCurrentXid, GlobalMaxActiveXid);
355
356         i = 0;
357         spin_lock(&cifs_tcp_ses_lock);
358         list_for_each(tmp1, &cifs_tcp_ses_list) {
359                 server = list_entry(tmp1, struct TCP_Server_Info,
360                                     tcp_ses_list);
361                 list_for_each(tmp2, &server->smb_ses_list) {
362                         ses = list_entry(tmp2, struct cifs_ses,
363                                          smb_ses_list);
364                         list_for_each(tmp3, &ses->tcon_list) {
365                                 tcon = list_entry(tmp3,
366                                                   struct cifs_tcon,
367                                                   tcon_list);
368                                 i++;
369                                 seq_printf(m, "\n%d) %s", i, tcon->treeName);
370                                 if (tcon->need_reconnect)
371                                         seq_puts(m, "\tDISCONNECTED ");
372                                 seq_printf(m, "\nSMBs: %d",
373                                            atomic_read(&tcon->num_smbs_sent));
374                                 if (server->ops->print_stats)
375                                         server->ops->print_stats(m, tcon);
376                         }
377                 }
378         }
379         spin_unlock(&cifs_tcp_ses_lock);
380
381         seq_putc(m, '\n');
382         return 0;
383 }
384
385 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
386 {
387         return single_open(file, cifs_stats_proc_show, NULL);
388 }
389
390 static const struct file_operations cifs_stats_proc_fops = {
391         .open           = cifs_stats_proc_open,
392         .read           = seq_read,
393         .llseek         = seq_lseek,
394         .release        = single_release,
395         .write          = cifs_stats_proc_write,
396 };
397 #endif /* STATS */
398
399 static struct proc_dir_entry *proc_fs_cifs;
400 static const struct file_operations cifsFYI_proc_fops;
401 static const struct file_operations cifs_lookup_cache_proc_fops;
402 static const struct file_operations traceSMB_proc_fops;
403 static const struct file_operations cifs_security_flags_proc_fops;
404 static const struct file_operations cifs_linux_ext_proc_fops;
405
406 void
407 cifs_proc_init(void)
408 {
409         proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
410         if (proc_fs_cifs == NULL)
411                 return;
412
413         proc_create("DebugData", 0, proc_fs_cifs, &cifs_debug_data_proc_fops);
414
415 #ifdef CONFIG_CIFS_STATS
416         proc_create("Stats", 0, proc_fs_cifs, &cifs_stats_proc_fops);
417 #endif /* STATS */
418         proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
419         proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
420         proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
421                     &cifs_linux_ext_proc_fops);
422         proc_create("SecurityFlags", 0, proc_fs_cifs,
423                     &cifs_security_flags_proc_fops);
424         proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
425                     &cifs_lookup_cache_proc_fops);
426 }
427
428 void
429 cifs_proc_clean(void)
430 {
431         if (proc_fs_cifs == NULL)
432                 return;
433
434         remove_proc_entry("DebugData", proc_fs_cifs);
435         remove_proc_entry("cifsFYI", proc_fs_cifs);
436         remove_proc_entry("traceSMB", proc_fs_cifs);
437 #ifdef CONFIG_CIFS_STATS
438         remove_proc_entry("Stats", proc_fs_cifs);
439 #endif
440         remove_proc_entry("SecurityFlags", proc_fs_cifs);
441         remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
442         remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
443         remove_proc_entry("fs/cifs", NULL);
444 }
445
446 static int cifsFYI_proc_show(struct seq_file *m, void *v)
447 {
448         seq_printf(m, "%d\n", cifsFYI);
449         return 0;
450 }
451
452 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
453 {
454         return single_open(file, cifsFYI_proc_show, NULL);
455 }
456
457 static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
458                 size_t count, loff_t *ppos)
459 {
460         char c[2] = { '\0' };
461         bool bv;
462         int rc;
463
464         rc = get_user(c[0], buffer);
465         if (rc)
466                 return rc;
467         if (strtobool(c, &bv) == 0)
468                 cifsFYI = bv;
469         else if ((c[0] > '1') && (c[0] <= '9'))
470                 cifsFYI = (int) (c[0] - '0'); /* see cifs_debug.h for meanings */
471
472         return count;
473 }
474
475 static const struct file_operations cifsFYI_proc_fops = {
476         .open           = cifsFYI_proc_open,
477         .read           = seq_read,
478         .llseek         = seq_lseek,
479         .release        = single_release,
480         .write          = cifsFYI_proc_write,
481 };
482
483 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
484 {
485         seq_printf(m, "%d\n", linuxExtEnabled);
486         return 0;
487 }
488
489 static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
490 {
491         return single_open(file, cifs_linux_ext_proc_show, NULL);
492 }
493
494 static ssize_t cifs_linux_ext_proc_write(struct file *file,
495                 const char __user *buffer, size_t count, loff_t *ppos)
496 {
497         int rc;
498
499         rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled);
500         if (rc)
501                 return rc;
502
503         return count;
504 }
505
506 static const struct file_operations cifs_linux_ext_proc_fops = {
507         .open           = cifs_linux_ext_proc_open,
508         .read           = seq_read,
509         .llseek         = seq_lseek,
510         .release        = single_release,
511         .write          = cifs_linux_ext_proc_write,
512 };
513
514 static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
515 {
516         seq_printf(m, "%d\n", lookupCacheEnabled);
517         return 0;
518 }
519
520 static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
521 {
522         return single_open(file, cifs_lookup_cache_proc_show, NULL);
523 }
524
525 static ssize_t cifs_lookup_cache_proc_write(struct file *file,
526                 const char __user *buffer, size_t count, loff_t *ppos)
527 {
528         int rc;
529
530         rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled);
531         if (rc)
532                 return rc;
533
534         return count;
535 }
536
537 static const struct file_operations cifs_lookup_cache_proc_fops = {
538         .open           = cifs_lookup_cache_proc_open,
539         .read           = seq_read,
540         .llseek         = seq_lseek,
541         .release        = single_release,
542         .write          = cifs_lookup_cache_proc_write,
543 };
544
545 static int traceSMB_proc_show(struct seq_file *m, void *v)
546 {
547         seq_printf(m, "%d\n", traceSMB);
548         return 0;
549 }
550
551 static int traceSMB_proc_open(struct inode *inode, struct file *file)
552 {
553         return single_open(file, traceSMB_proc_show, NULL);
554 }
555
556 static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
557                 size_t count, loff_t *ppos)
558 {
559         int rc;
560
561         rc = kstrtobool_from_user(buffer, count, &traceSMB);
562         if (rc)
563                 return rc;
564
565         return count;
566 }
567
568 static const struct file_operations traceSMB_proc_fops = {
569         .open           = traceSMB_proc_open,
570         .read           = seq_read,
571         .llseek         = seq_lseek,
572         .release        = single_release,
573         .write          = traceSMB_proc_write,
574 };
575
576 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
577 {
578         seq_printf(m, "0x%x\n", global_secflags);
579         return 0;
580 }
581
582 static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
583 {
584         return single_open(file, cifs_security_flags_proc_show, NULL);
585 }
586
587 /*
588  * Ensure that if someone sets a MUST flag, that we disable all other MAY
589  * flags except for the ones corresponding to the given MUST flag. If there are
590  * multiple MUST flags, then try to prefer more secure ones.
591  */
592 static void
593 cifs_security_flags_handle_must_flags(unsigned int *flags)
594 {
595         unsigned int signflags = *flags & CIFSSEC_MUST_SIGN;
596
597         if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
598                 *flags = CIFSSEC_MUST_KRB5;
599         else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
600                 *flags = CIFSSEC_MUST_NTLMSSP;
601         else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
602                 *flags = CIFSSEC_MUST_NTLMV2;
603         else if ((*flags & CIFSSEC_MUST_NTLM) == CIFSSEC_MUST_NTLM)
604                 *flags = CIFSSEC_MUST_NTLM;
605         else if (CIFSSEC_MUST_LANMAN &&
606                  (*flags & CIFSSEC_MUST_LANMAN) == CIFSSEC_MUST_LANMAN)
607                 *flags = CIFSSEC_MUST_LANMAN;
608         else if (CIFSSEC_MUST_PLNTXT &&
609                  (*flags & CIFSSEC_MUST_PLNTXT) == CIFSSEC_MUST_PLNTXT)
610                 *flags = CIFSSEC_MUST_PLNTXT;
611
612         *flags |= signflags;
613 }
614
615 static ssize_t cifs_security_flags_proc_write(struct file *file,
616                 const char __user *buffer, size_t count, loff_t *ppos)
617 {
618         int rc;
619         unsigned int flags;
620         char flags_string[12];
621         bool bv;
622
623         if ((count < 1) || (count > 11))
624                 return -EINVAL;
625
626         memset(flags_string, 0, 12);
627
628         if (copy_from_user(flags_string, buffer, count))
629                 return -EFAULT;
630
631         if (count < 3) {
632                 /* single char or single char followed by null */
633                 if (strtobool(flags_string, &bv) == 0) {
634                         global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF;
635                         return count;
636                 } else if (!isdigit(flags_string[0])) {
637                         cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
638                                         flags_string);
639                         return -EINVAL;
640                 }
641         }
642
643         /* else we have a number */
644         rc = kstrtouint(flags_string, 0, &flags);
645         if (rc) {
646                 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
647                                 flags_string);
648                 return rc;
649         }
650
651         cifs_dbg(FYI, "sec flags 0x%x\n", flags);
652
653         if (flags == 0)  {
654                 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string);
655                 return -EINVAL;
656         }
657
658         if (flags & ~CIFSSEC_MASK) {
659                 cifs_dbg(VFS, "Unsupported security flags: 0x%x\n",
660                          flags & ~CIFSSEC_MASK);
661                 return -EINVAL;
662         }
663
664         cifs_security_flags_handle_must_flags(&flags);
665
666         /* flags look ok - update the global security flags for cifs module */
667         global_secflags = flags;
668         if (global_secflags & CIFSSEC_MUST_SIGN) {
669                 /* requiring signing implies signing is allowed */
670                 global_secflags |= CIFSSEC_MAY_SIGN;
671                 cifs_dbg(FYI, "packet signing now required\n");
672         } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) {
673                 cifs_dbg(FYI, "packet signing disabled\n");
674         }
675         /* BB should we turn on MAY flags for other MUST options? */
676         return count;
677 }
678
679 static const struct file_operations cifs_security_flags_proc_fops = {
680         .open           = cifs_security_flags_proc_open,
681         .read           = seq_read,
682         .llseek         = seq_lseek,
683         .release        = single_release,
684         .write          = cifs_security_flags_proc_write,
685 };
686 #else
687 inline void cifs_proc_init(void)
688 {
689 }
690
691 inline void cifs_proc_clean(void)
692 {
693 }
694 #endif /* PROC_FS */