cifs: get rid of blind d_drop() in readdir
[linux-3.10.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         int i, j;
38         int *intptr = data;
39         char *charptr = data;
40         char buf[10], line[80];
41
42         printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n",
43                 label, length, data);
44         for (i = 0; i < length; i += 16) {
45                 line[0] = 0;
46                 for (j = 0; (j < 4) && (i + j * 4 < length); j++) {
47                         sprintf(buf, " %08x", intptr[i / 4 + j]);
48                         strcat(line, buf);
49                 }
50                 buf[0] = ' ';
51                 buf[2] = 0;
52                 for (j = 0; (j < 16) && (i + j < length); j++) {
53                         buf[1] = isprint(charptr[i + j]) ? charptr[i + j] : '.';
54                         strcat(line, buf);
55                 }
56                 printk(KERN_DEBUG "%s\n", line);
57         }
58 }
59
60 void 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
72 void 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
111 static 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
240 static 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
245 static 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
254 static 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
296 static 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
358 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
359 {
360         return single_open(file, cifs_stats_proc_show, NULL);
361 }
362
363 static 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
373 static struct proc_dir_entry *proc_fs_cifs;
374 static const struct file_operations cifsFYI_proc_fops;
375 static const struct file_operations cifs_lookup_cache_proc_fops;
376 static const struct file_operations traceSMB_proc_fops;
377 static const struct file_operations cifs_security_flags_proc_fops;
378 static const struct file_operations cifs_linux_ext_proc_fops;
379
380 void
381 cifs_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
402 void
403 cifs_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
420 static int cifsFYI_proc_show(struct seq_file *m, void *v)
421 {
422         seq_printf(m, "%d\n", cifsFYI);
423         return 0;
424 }
425
426 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
427 {
428         return single_open(file, cifsFYI_proc_show, NULL);
429 }
430
431 static 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
450 static 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
459 static 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
465 static 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
470 static 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
487 static 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
496 static 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
502 static 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
507 static 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
524 static 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
533 static int traceSMB_proc_show(struct seq_file *m, void *v)
534 {
535         seq_printf(m, "%d\n", traceSMB);
536         return 0;
537 }
538
539 static int traceSMB_proc_open(struct inode *inode, struct file *file)
540 {
541         return single_open(file, traceSMB_proc_show, NULL);
542 }
543
544 static 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
561 static 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
570 static 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
576 static 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
581 static 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
639 static 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
648 inline void cifs_proc_init(void)
649 {
650 }
651
652 inline void cifs_proc_clean(void)
653 {
654 }
655 #endif /* PROC_FS */