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
cifs_dump_mem(char * label,void * data,int length)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
cifs_vfs_err(const char * fmt,...)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
cifs_dump_detail(void * buf)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
cifs_dump_mids(struct TCP_Server_Info * server)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
cifs_debug_data_proc_show(struct seq_file * m,void * v)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
cifs_debug_data_proc_open(struct inode * inode,struct file * file)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 .owner = THIS_MODULE,
265 .open = cifs_debug_data_proc_open,
266 .read = seq_read,
267 .llseek = seq_lseek,
268 .release = single_release,
269 };
270
271 #ifdef CONFIG_CIFS_STATS
cifs_stats_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)272 static ssize_t cifs_stats_proc_write(struct file *file,
273 const char __user *buffer, size_t count, loff_t *ppos)
274 {
275 bool bv;
276 int rc;
277 struct list_head *tmp1, *tmp2, *tmp3;
278 struct TCP_Server_Info *server;
279 struct cifs_ses *ses;
280 struct cifs_tcon *tcon;
281
282 rc = kstrtobool_from_user(buffer, count, &bv);
283 if (rc == 0) {
284 #ifdef CONFIG_CIFS_STATS2
285 atomic_set(&totBufAllocCount, 0);
286 atomic_set(&totSmBufAllocCount, 0);
287 #endif /* CONFIG_CIFS_STATS2 */
288 atomic_set(&tcpSesReconnectCount, 0);
289 atomic_set(&tconInfoReconnectCount, 0);
290
291 spin_lock(&GlobalMid_Lock);
292 GlobalMaxActiveXid = 0;
293 GlobalCurrentXid = 0;
294 spin_unlock(&GlobalMid_Lock);
295 spin_lock(&cifs_tcp_ses_lock);
296 list_for_each(tmp1, &cifs_tcp_ses_list) {
297 server = list_entry(tmp1, struct TCP_Server_Info,
298 tcp_ses_list);
299 list_for_each(tmp2, &server->smb_ses_list) {
300 ses = list_entry(tmp2, struct cifs_ses,
301 smb_ses_list);
302 list_for_each(tmp3, &ses->tcon_list) {
303 tcon = list_entry(tmp3,
304 struct cifs_tcon,
305 tcon_list);
306 atomic_set(&tcon->num_smbs_sent, 0);
307 spin_lock(&tcon->stat_lock);
308 tcon->bytes_read = 0;
309 tcon->bytes_written = 0;
310 spin_unlock(&tcon->stat_lock);
311 if (server->ops->clear_stats)
312 server->ops->clear_stats(tcon);
313 }
314 }
315 }
316 spin_unlock(&cifs_tcp_ses_lock);
317 } else {
318 return rc;
319 }
320
321 return count;
322 }
323
cifs_stats_proc_show(struct seq_file * m,void * v)324 static int cifs_stats_proc_show(struct seq_file *m, void *v)
325 {
326 int i;
327 struct list_head *tmp1, *tmp2, *tmp3;
328 struct TCP_Server_Info *server;
329 struct cifs_ses *ses;
330 struct cifs_tcon *tcon;
331
332 seq_printf(m,
333 "Resources in use\nCIFS Session: %d\n",
334 sesInfoAllocCount.counter);
335 seq_printf(m, "Share (unique mount targets): %d\n",
336 tconInfoAllocCount.counter);
337 seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
338 bufAllocCount.counter,
339 cifs_min_rcv + tcpSesAllocCount.counter);
340 seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
341 smBufAllocCount.counter, cifs_min_small);
342 #ifdef CONFIG_CIFS_STATS2
343 seq_printf(m, "Total Large %d Small %d Allocations\n",
344 atomic_read(&totBufAllocCount),
345 atomic_read(&totSmBufAllocCount));
346 #endif /* CONFIG_CIFS_STATS2 */
347
348 seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount));
349 seq_printf(m,
350 "\n%d session %d share reconnects\n",
351 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
352
353 seq_printf(m,
354 "Total vfs operations: %d maximum at one time: %d\n",
355 GlobalCurrentXid, GlobalMaxActiveXid);
356
357 i = 0;
358 spin_lock(&cifs_tcp_ses_lock);
359 list_for_each(tmp1, &cifs_tcp_ses_list) {
360 server = list_entry(tmp1, struct TCP_Server_Info,
361 tcp_ses_list);
362 list_for_each(tmp2, &server->smb_ses_list) {
363 ses = list_entry(tmp2, struct cifs_ses,
364 smb_ses_list);
365 list_for_each(tmp3, &ses->tcon_list) {
366 tcon = list_entry(tmp3,
367 struct cifs_tcon,
368 tcon_list);
369 i++;
370 seq_printf(m, "\n%d) %s", i, tcon->treeName);
371 if (tcon->need_reconnect)
372 seq_puts(m, "\tDISCONNECTED ");
373 seq_printf(m, "\nSMBs: %d",
374 atomic_read(&tcon->num_smbs_sent));
375 if (server->ops->print_stats)
376 server->ops->print_stats(m, tcon);
377 }
378 }
379 }
380 spin_unlock(&cifs_tcp_ses_lock);
381
382 seq_putc(m, '\n');
383 return 0;
384 }
385
cifs_stats_proc_open(struct inode * inode,struct file * file)386 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
387 {
388 return single_open(file, cifs_stats_proc_show, NULL);
389 }
390
391 static const struct file_operations cifs_stats_proc_fops = {
392 .owner = THIS_MODULE,
393 .open = cifs_stats_proc_open,
394 .read = seq_read,
395 .llseek = seq_lseek,
396 .release = single_release,
397 .write = cifs_stats_proc_write,
398 };
399 #endif /* STATS */
400
401 static struct proc_dir_entry *proc_fs_cifs;
402 static const struct file_operations cifsFYI_proc_fops;
403 static const struct file_operations cifs_lookup_cache_proc_fops;
404 static const struct file_operations traceSMB_proc_fops;
405 static const struct file_operations cifs_security_flags_proc_fops;
406 static const struct file_operations cifs_linux_ext_proc_fops;
407
408 void
cifs_proc_init(void)409 cifs_proc_init(void)
410 {
411 proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
412 if (proc_fs_cifs == NULL)
413 return;
414
415 proc_create("DebugData", 0, proc_fs_cifs, &cifs_debug_data_proc_fops);
416
417 #ifdef CONFIG_CIFS_STATS
418 proc_create("Stats", 0, proc_fs_cifs, &cifs_stats_proc_fops);
419 #endif /* STATS */
420 proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
421 proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
422 proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
423 &cifs_linux_ext_proc_fops);
424 proc_create("SecurityFlags", 0, proc_fs_cifs,
425 &cifs_security_flags_proc_fops);
426 proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
427 &cifs_lookup_cache_proc_fops);
428 }
429
430 void
cifs_proc_clean(void)431 cifs_proc_clean(void)
432 {
433 if (proc_fs_cifs == NULL)
434 return;
435
436 remove_proc_entry("DebugData", proc_fs_cifs);
437 remove_proc_entry("cifsFYI", proc_fs_cifs);
438 remove_proc_entry("traceSMB", proc_fs_cifs);
439 #ifdef CONFIG_CIFS_STATS
440 remove_proc_entry("Stats", proc_fs_cifs);
441 #endif
442 remove_proc_entry("SecurityFlags", proc_fs_cifs);
443 remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
444 remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
445 remove_proc_entry("fs/cifs", NULL);
446 }
447
cifsFYI_proc_show(struct seq_file * m,void * v)448 static int cifsFYI_proc_show(struct seq_file *m, void *v)
449 {
450 seq_printf(m, "%d\n", cifsFYI);
451 return 0;
452 }
453
cifsFYI_proc_open(struct inode * inode,struct file * file)454 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
455 {
456 return single_open(file, cifsFYI_proc_show, NULL);
457 }
458
cifsFYI_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)459 static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
460 size_t count, loff_t *ppos)
461 {
462 char c[2] = { '\0' };
463 bool bv;
464 int rc;
465
466 rc = get_user(c[0], buffer);
467 if (rc)
468 return rc;
469 if (strtobool(c, &bv) == 0)
470 cifsFYI = bv;
471 else if ((c[0] > '1') && (c[0] <= '9'))
472 cifsFYI = (int) (c[0] - '0'); /* see cifs_debug.h for meanings */
473
474 return count;
475 }
476
477 static const struct file_operations cifsFYI_proc_fops = {
478 .owner = THIS_MODULE,
479 .open = cifsFYI_proc_open,
480 .read = seq_read,
481 .llseek = seq_lseek,
482 .release = single_release,
483 .write = cifsFYI_proc_write,
484 };
485
cifs_linux_ext_proc_show(struct seq_file * m,void * v)486 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
487 {
488 seq_printf(m, "%d\n", linuxExtEnabled);
489 return 0;
490 }
491
cifs_linux_ext_proc_open(struct inode * inode,struct file * file)492 static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
493 {
494 return single_open(file, cifs_linux_ext_proc_show, NULL);
495 }
496
cifs_linux_ext_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)497 static ssize_t cifs_linux_ext_proc_write(struct file *file,
498 const char __user *buffer, size_t count, loff_t *ppos)
499 {
500 int rc;
501
502 rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled);
503 if (rc)
504 return rc;
505
506 return count;
507 }
508
509 static const struct file_operations cifs_linux_ext_proc_fops = {
510 .owner = THIS_MODULE,
511 .open = cifs_linux_ext_proc_open,
512 .read = seq_read,
513 .llseek = seq_lseek,
514 .release = single_release,
515 .write = cifs_linux_ext_proc_write,
516 };
517
cifs_lookup_cache_proc_show(struct seq_file * m,void * v)518 static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
519 {
520 seq_printf(m, "%d\n", lookupCacheEnabled);
521 return 0;
522 }
523
cifs_lookup_cache_proc_open(struct inode * inode,struct file * file)524 static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
525 {
526 return single_open(file, cifs_lookup_cache_proc_show, NULL);
527 }
528
cifs_lookup_cache_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)529 static ssize_t cifs_lookup_cache_proc_write(struct file *file,
530 const char __user *buffer, size_t count, loff_t *ppos)
531 {
532 int rc;
533
534 rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled);
535 if (rc)
536 return rc;
537
538 return count;
539 }
540
541 static const struct file_operations cifs_lookup_cache_proc_fops = {
542 .owner = THIS_MODULE,
543 .open = cifs_lookup_cache_proc_open,
544 .read = seq_read,
545 .llseek = seq_lseek,
546 .release = single_release,
547 .write = cifs_lookup_cache_proc_write,
548 };
549
traceSMB_proc_show(struct seq_file * m,void * v)550 static int traceSMB_proc_show(struct seq_file *m, void *v)
551 {
552 seq_printf(m, "%d\n", traceSMB);
553 return 0;
554 }
555
traceSMB_proc_open(struct inode * inode,struct file * file)556 static int traceSMB_proc_open(struct inode *inode, struct file *file)
557 {
558 return single_open(file, traceSMB_proc_show, NULL);
559 }
560
traceSMB_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)561 static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
562 size_t count, loff_t *ppos)
563 {
564 int rc;
565
566 rc = kstrtobool_from_user(buffer, count, &traceSMB);
567 if (rc)
568 return rc;
569
570 return count;
571 }
572
573 static const struct file_operations traceSMB_proc_fops = {
574 .owner = THIS_MODULE,
575 .open = traceSMB_proc_open,
576 .read = seq_read,
577 .llseek = seq_lseek,
578 .release = single_release,
579 .write = traceSMB_proc_write,
580 };
581
cifs_security_flags_proc_show(struct seq_file * m,void * v)582 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
583 {
584 seq_printf(m, "0x%x\n", global_secflags);
585 return 0;
586 }
587
cifs_security_flags_proc_open(struct inode * inode,struct file * file)588 static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
589 {
590 return single_open(file, cifs_security_flags_proc_show, NULL);
591 }
592
593 /*
594 * Ensure that if someone sets a MUST flag, that we disable all other MAY
595 * flags except for the ones corresponding to the given MUST flag. If there are
596 * multiple MUST flags, then try to prefer more secure ones.
597 */
598 static void
cifs_security_flags_handle_must_flags(unsigned int * flags)599 cifs_security_flags_handle_must_flags(unsigned int *flags)
600 {
601 unsigned int signflags = *flags & CIFSSEC_MUST_SIGN;
602
603 if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
604 *flags = CIFSSEC_MUST_KRB5;
605 else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
606 *flags = CIFSSEC_MUST_NTLMSSP;
607 else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
608 *flags = CIFSSEC_MUST_NTLMV2;
609 else if ((*flags & CIFSSEC_MUST_NTLM) == CIFSSEC_MUST_NTLM)
610 *flags = CIFSSEC_MUST_NTLM;
611 else if (CIFSSEC_MUST_LANMAN &&
612 (*flags & CIFSSEC_MUST_LANMAN) == CIFSSEC_MUST_LANMAN)
613 *flags = CIFSSEC_MUST_LANMAN;
614 else if (CIFSSEC_MUST_PLNTXT &&
615 (*flags & CIFSSEC_MUST_PLNTXT) == CIFSSEC_MUST_PLNTXT)
616 *flags = CIFSSEC_MUST_PLNTXT;
617
618 *flags |= signflags;
619 }
620
cifs_security_flags_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)621 static ssize_t cifs_security_flags_proc_write(struct file *file,
622 const char __user *buffer, size_t count, loff_t *ppos)
623 {
624 int rc;
625 unsigned int flags;
626 char flags_string[12];
627 bool bv;
628
629 if ((count < 1) || (count > 11))
630 return -EINVAL;
631
632 memset(flags_string, 0, 12);
633
634 if (copy_from_user(flags_string, buffer, count))
635 return -EFAULT;
636
637 if (count < 3) {
638 /* single char or single char followed by null */
639 if (strtobool(flags_string, &bv) == 0) {
640 global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF;
641 return count;
642 } else if (!isdigit(flags_string[0])) {
643 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
644 flags_string);
645 return -EINVAL;
646 }
647 }
648
649 /* else we have a number */
650 rc = kstrtouint(flags_string, 0, &flags);
651 if (rc) {
652 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
653 flags_string);
654 return rc;
655 }
656
657 cifs_dbg(FYI, "sec flags 0x%x\n", flags);
658
659 if (flags == 0) {
660 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string);
661 return -EINVAL;
662 }
663
664 if (flags & ~CIFSSEC_MASK) {
665 cifs_dbg(VFS, "Unsupported security flags: 0x%x\n",
666 flags & ~CIFSSEC_MASK);
667 return -EINVAL;
668 }
669
670 cifs_security_flags_handle_must_flags(&flags);
671
672 /* flags look ok - update the global security flags for cifs module */
673 global_secflags = flags;
674 if (global_secflags & CIFSSEC_MUST_SIGN) {
675 /* requiring signing implies signing is allowed */
676 global_secflags |= CIFSSEC_MAY_SIGN;
677 cifs_dbg(FYI, "packet signing now required\n");
678 } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) {
679 cifs_dbg(FYI, "packet signing disabled\n");
680 }
681 /* BB should we turn on MAY flags for other MUST options? */
682 return count;
683 }
684
685 static const struct file_operations cifs_security_flags_proc_fops = {
686 .owner = THIS_MODULE,
687 .open = cifs_security_flags_proc_open,
688 .read = seq_read,
689 .llseek = seq_lseek,
690 .release = single_release,
691 .write = cifs_security_flags_proc_write,
692 };
693 #else
cifs_proc_init(void)694 inline void cifs_proc_init(void)
695 {
696 }
697
cifs_proc_clean(void)698 inline void cifs_proc_clean(void)
699 {
700 }
701 #endif /* PROC_FS */
702