Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/cifs_debug.c |
| 3 | * |
Steve French | b8643e1 | 2005-04-28 22:41:07 -0700 | [diff] [blame] | 4 | * Copyright (C) International Business Machines Corp., 2000,2005 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 10 | * the Free Software Foundation; either version 2 of the License, or |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | * (at your option) any later version. |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 12 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 19 | * along with this program; if not, write to the Free Software |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 27 | #include <linux/uaccess.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include "cifspdu.h" |
| 29 | #include "cifsglob.h" |
| 30 | #include "cifsproto.h" |
| 31 | #include "cifs_debug.h" |
Steve French | 6c91d36 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 32 | #include "cifsfs.h" |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 33 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 34 | #include "smbdirect.h" |
| 35 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | |
| 37 | void |
| 38 | cifs_dump_mem(char *label, void *data, int length) |
| 39 | { |
Andy Shevchenko | 0b456f0 | 2014-08-27 16:49:44 +0300 | [diff] [blame] | 40 | pr_debug("%s: dump of %d bytes of data at 0x%p\n", label, length, data); |
Andy Shevchenko | 55d83e0 | 2014-08-27 16:49:43 +0300 | [diff] [blame] | 41 | print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 4, |
| 42 | data, length, true); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | } |
| 44 | |
Ronnie Sahlberg | 14547f7 | 2018-04-22 14:45:53 -0600 | [diff] [blame] | 45 | void cifs_dump_detail(void *buf, struct TCP_Server_Info *server) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 46 | { |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 47 | #ifdef CONFIG_CIFS_DEBUG2 |
Pavel Shilovsky | d4e4854 | 2012-03-23 14:28:02 -0400 | [diff] [blame] | 48 | struct smb_hdr *smb = (struct smb_hdr *)buf; |
| 49 | |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 50 | cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d\n", |
| 51 | smb->Command, smb->Status.CifsError, |
| 52 | smb->Flags, smb->Flags2, smb->Mid, smb->Pid); |
Ronnie Sahlberg | 14547f7 | 2018-04-22 14:45:53 -0600 | [diff] [blame] | 53 | cifs_dbg(VFS, "smb buf %p len %u\n", smb, |
Steve French | 71992e62 | 2018-05-06 15:58:51 -0500 | [diff] [blame] | 54 | server->ops->calc_smb_size(smb, server)); |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 55 | #endif /* CONFIG_CIFS_DEBUG2 */ |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 56 | } |
| 57 | |
Steve French | ffdd6e4 | 2007-06-24 21:15:44 +0000 | [diff] [blame] | 58 | void cifs_dump_mids(struct TCP_Server_Info *server) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 59 | { |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 60 | #ifdef CONFIG_CIFS_DEBUG2 |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 61 | struct list_head *tmp; |
Steve French | ffdd6e4 | 2007-06-24 21:15:44 +0000 | [diff] [blame] | 62 | struct mid_q_entry *mid_entry; |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 63 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 64 | if (server == NULL) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 65 | return; |
| 66 | |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 67 | cifs_dbg(VFS, "Dump pending requests:\n"); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 68 | spin_lock(&GlobalMid_Lock); |
| 69 | list_for_each(tmp, &server->pending_mid_q) { |
| 70 | mid_entry = list_entry(tmp, struct mid_q_entry, qhead); |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 71 | cifs_dbg(VFS, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu\n", |
| 72 | mid_entry->mid_state, |
| 73 | le16_to_cpu(mid_entry->command), |
| 74 | mid_entry->pid, |
| 75 | mid_entry->callback_data, |
| 76 | mid_entry->mid); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 77 | #ifdef CONFIG_CIFS_STATS2 |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 78 | cifs_dbg(VFS, "IsLarge: %d buf: %p time rcv: %ld now: %ld\n", |
| 79 | mid_entry->large_buf, |
| 80 | mid_entry->resp_buf, |
| 81 | mid_entry->when_received, |
| 82 | jiffies); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 83 | #endif /* STATS2 */ |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 84 | cifs_dbg(VFS, "IsMult: %d IsEnd: %d\n", |
| 85 | mid_entry->multiRsp, mid_entry->multiEnd); |
Steve French | ad8b15f | 2008-08-08 21:10:16 +0000 | [diff] [blame] | 86 | if (mid_entry->resp_buf) { |
Steve French | 71992e62 | 2018-05-06 15:58:51 -0500 | [diff] [blame] | 87 | cifs_dump_detail(mid_entry->resp_buf, server); |
Steve French | ad8b15f | 2008-08-08 21:10:16 +0000 | [diff] [blame] | 88 | cifs_dump_mem("existing buf: ", |
| 89 | mid_entry->resp_buf, 62); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 90 | } |
| 91 | } |
| 92 | spin_unlock(&GlobalMid_Lock); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 93 | #endif /* CONFIG_CIFS_DEBUG2 */ |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 94 | } |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 95 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | #ifdef CONFIG_PROC_FS |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 97 | static void cifs_debug_tcon(struct seq_file *m, struct cifs_tcon *tcon) |
| 98 | { |
| 99 | __u32 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType); |
| 100 | |
| 101 | seq_printf(m, "%s Mounts: %d ", tcon->treeName, tcon->tc_count); |
| 102 | if (tcon->nativeFileSystem) |
| 103 | seq_printf(m, "Type: %s ", tcon->nativeFileSystem); |
| 104 | seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x\n\tPathComponentMax: %d Status: %d", |
| 105 | le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics), |
| 106 | le32_to_cpu(tcon->fsAttrInfo.Attributes), |
| 107 | le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength), |
| 108 | tcon->tidStatus); |
| 109 | if (dev_type == FILE_DEVICE_DISK) |
| 110 | seq_puts(m, " type: DISK "); |
| 111 | else if (dev_type == FILE_DEVICE_CD_ROM) |
| 112 | seq_puts(m, " type: CDROM "); |
| 113 | else |
| 114 | seq_printf(m, " type: %d ", dev_type); |
Steve French | ede2e52 | 2018-01-31 14:34:37 -0600 | [diff] [blame] | 115 | if (tcon->seal) |
| 116 | seq_printf(m, " Encrypted"); |
Steve French | 5c5a41be | 2018-05-30 17:11:55 -0500 | [diff] [blame] | 117 | if (tcon->nocase) |
| 118 | seq_printf(m, " nocase"); |
Steve French | ede2e52 | 2018-01-31 14:34:37 -0600 | [diff] [blame] | 119 | if (tcon->unix_ext) |
| 120 | seq_printf(m, " POSIX Extensions"); |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 121 | if (tcon->ses->server->ops->dump_share_caps) |
| 122 | tcon->ses->server->ops->dump_share_caps(m, tcon); |
| 123 | |
| 124 | if (tcon->need_reconnect) |
| 125 | seq_puts(m, "\tDISCONNECTED "); |
| 126 | seq_putc(m, '\n'); |
| 127 | } |
| 128 | |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 129 | static void |
| 130 | cifs_dump_iface(struct seq_file *m, struct cifs_server_iface *iface) |
| 131 | { |
| 132 | struct sockaddr_in *ipv4 = (struct sockaddr_in *)&iface->sockaddr; |
| 133 | struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&iface->sockaddr; |
| 134 | |
| 135 | seq_printf(m, "\t\tSpeed: %zu bps\n", iface->speed); |
| 136 | seq_puts(m, "\t\tCapabilities: "); |
| 137 | if (iface->rdma_capable) |
| 138 | seq_puts(m, "rdma "); |
| 139 | if (iface->rss_capable) |
| 140 | seq_puts(m, "rss "); |
| 141 | seq_putc(m, '\n'); |
| 142 | if (iface->sockaddr.ss_family == AF_INET) |
| 143 | seq_printf(m, "\t\tIPv4: %pI4\n", &ipv4->sin_addr); |
| 144 | else if (iface->sockaddr.ss_family == AF_INET6) |
| 145 | seq_printf(m, "\t\tIPv6: %pI6\n", &ipv6->sin6_addr); |
| 146 | } |
| 147 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 148 | static int cifs_debug_data_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | { |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 150 | struct list_head *tmp1, *tmp2, *tmp3; |
Steve French | ffdd6e4 | 2007-06-24 21:15:44 +0000 | [diff] [blame] | 151 | struct mid_q_entry *mid_entry; |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 152 | struct TCP_Server_Info *server; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 153 | struct cifs_ses *ses; |
| 154 | struct cifs_tcon *tcon; |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 155 | int i, j; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 157 | seq_puts(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | "Display Internal CIFS Data Structures for Debugging\n" |
| 159 | "---------------------------------------------------\n"); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 160 | seq_printf(m, "CIFS Version %s\n", CIFS_VERSION); |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 161 | seq_printf(m, "Features:"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 162 | #ifdef CONFIG_CIFS_DFS_UPCALL |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 163 | seq_printf(m, " dfs"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 164 | #endif |
| 165 | #ifdef CONFIG_CIFS_FSCACHE |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 166 | seq_printf(m, " fscache"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 167 | #endif |
| 168 | #ifdef CONFIG_CIFS_WEAK_PW_HASH |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 169 | seq_printf(m, " lanman"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 170 | #endif |
| 171 | #ifdef CONFIG_CIFS_POSIX |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 172 | seq_printf(m, " posix"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 173 | #endif |
| 174 | #ifdef CONFIG_CIFS_UPCALL |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 175 | seq_printf(m, " spnego"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 176 | #endif |
| 177 | #ifdef CONFIG_CIFS_XATTR |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 178 | seq_printf(m, " xattr"); |
| 179 | #endif |
| 180 | #ifdef CONFIG_CIFS_ACL |
| 181 | seq_printf(m, " acl"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 182 | #endif |
| 183 | seq_putc(m, '\n'); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 184 | seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid); |
| 185 | seq_printf(m, "Servers:"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | |
| 187 | i = 0; |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 188 | spin_lock(&cifs_tcp_ses_lock); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 189 | list_for_each(tmp1, &cifs_tcp_ses_list) { |
| 190 | server = list_entry(tmp1, struct TCP_Server_Info, |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 191 | tcp_ses_list); |
Long Li | 08a3b96 | 2017-11-22 17:38:48 -0700 | [diff] [blame] | 192 | |
| 193 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 194 | if (!server->rdma) |
| 195 | goto skip_rdma; |
| 196 | |
| 197 | seq_printf(m, "\nSMBDirect (in hex) protocol version: %x " |
| 198 | "transport status: %x", |
| 199 | server->smbd_conn->protocol, |
| 200 | server->smbd_conn->transport_status); |
| 201 | seq_printf(m, "\nConn receive_credit_max: %x " |
| 202 | "send_credit_target: %x max_send_size: %x", |
| 203 | server->smbd_conn->receive_credit_max, |
| 204 | server->smbd_conn->send_credit_target, |
| 205 | server->smbd_conn->max_send_size); |
| 206 | seq_printf(m, "\nConn max_fragmented_recv_size: %x " |
| 207 | "max_fragmented_send_size: %x max_receive_size:%x", |
| 208 | server->smbd_conn->max_fragmented_recv_size, |
| 209 | server->smbd_conn->max_fragmented_send_size, |
| 210 | server->smbd_conn->max_receive_size); |
| 211 | seq_printf(m, "\nConn keep_alive_interval: %x " |
| 212 | "max_readwrite_size: %x rdma_readwrite_threshold: %x", |
| 213 | server->smbd_conn->keep_alive_interval, |
| 214 | server->smbd_conn->max_readwrite_size, |
| 215 | server->smbd_conn->rdma_readwrite_threshold); |
| 216 | seq_printf(m, "\nDebug count_get_receive_buffer: %x " |
| 217 | "count_put_receive_buffer: %x count_send_empty: %x", |
| 218 | server->smbd_conn->count_get_receive_buffer, |
| 219 | server->smbd_conn->count_put_receive_buffer, |
| 220 | server->smbd_conn->count_send_empty); |
| 221 | seq_printf(m, "\nRead Queue count_reassembly_queue: %x " |
| 222 | "count_enqueue_reassembly_queue: %x " |
| 223 | "count_dequeue_reassembly_queue: %x " |
| 224 | "fragment_reassembly_remaining: %x " |
| 225 | "reassembly_data_length: %x " |
| 226 | "reassembly_queue_length: %x", |
| 227 | server->smbd_conn->count_reassembly_queue, |
| 228 | server->smbd_conn->count_enqueue_reassembly_queue, |
| 229 | server->smbd_conn->count_dequeue_reassembly_queue, |
| 230 | server->smbd_conn->fragment_reassembly_remaining, |
| 231 | server->smbd_conn->reassembly_data_length, |
| 232 | server->smbd_conn->reassembly_queue_length); |
| 233 | seq_printf(m, "\nCurrent Credits send_credits: %x " |
| 234 | "receive_credits: %x receive_credit_target: %x", |
| 235 | atomic_read(&server->smbd_conn->send_credits), |
| 236 | atomic_read(&server->smbd_conn->receive_credits), |
| 237 | server->smbd_conn->receive_credit_target); |
| 238 | seq_printf(m, "\nPending send_pending: %x send_payload_pending:" |
| 239 | " %x smbd_send_pending: %x smbd_recv_pending: %x", |
| 240 | atomic_read(&server->smbd_conn->send_pending), |
| 241 | atomic_read(&server->smbd_conn->send_payload_pending), |
| 242 | server->smbd_conn->smbd_send_pending, |
| 243 | server->smbd_conn->smbd_recv_pending); |
| 244 | seq_printf(m, "\nReceive buffers count_receive_queue: %x " |
| 245 | "count_empty_packet_queue: %x", |
| 246 | server->smbd_conn->count_receive_queue, |
| 247 | server->smbd_conn->count_empty_packet_queue); |
| 248 | seq_printf(m, "\nMR responder_resources: %x " |
| 249 | "max_frmr_depth: %x mr_type: %x", |
| 250 | server->smbd_conn->responder_resources, |
| 251 | server->smbd_conn->max_frmr_depth, |
| 252 | server->smbd_conn->mr_type); |
| 253 | seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x", |
| 254 | atomic_read(&server->smbd_conn->mr_ready_count), |
| 255 | atomic_read(&server->smbd_conn->mr_used_count)); |
| 256 | skip_rdma: |
| 257 | #endif |
Steve French | ede2e52 | 2018-01-31 14:34:37 -0600 | [diff] [blame] | 258 | seq_printf(m, "\nNumber of credits: %d Dialect 0x%x", |
| 259 | server->credits, server->dialect); |
| 260 | if (server->sign) |
| 261 | seq_printf(m, " signed"); |
Steve French | fcef0db | 2018-05-19 20:45:27 -0500 | [diff] [blame] | 262 | #ifdef CONFIG_CIFS_SMB311 |
| 263 | if (server->posix_ext_supported) |
| 264 | seq_printf(m, " posix"); |
| 265 | #endif /* 3.1.1 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | i++; |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 267 | list_for_each(tmp2, &server->smb_ses_list) { |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 268 | ses = list_entry(tmp2, struct cifs_ses, |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 269 | smb_ses_list); |
| 270 | if ((ses->serverDomain == NULL) || |
| 271 | (ses->serverOS == NULL) || |
| 272 | (ses->serverNOS == NULL)) { |
Steve French | 1fa089e | 2017-09-20 16:46:49 -0500 | [diff] [blame] | 273 | seq_printf(m, "\n%d) Name: %s Uses: %d Capability: 0x%x\tSession Status: %d\t", |
| 274 | i, ses->serverName, ses->ses_count, |
| 275 | ses->capabilities, ses->status); |
| 276 | if (ses->session_flags & SMB2_SESSION_FLAG_IS_GUEST) |
| 277 | seq_printf(m, "Guest\t"); |
| 278 | else if (ses->session_flags & SMB2_SESSION_FLAG_IS_NULL) |
| 279 | seq_printf(m, "Anonymous\t"); |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 280 | } else { |
| 281 | seq_printf(m, |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 282 | "\n%d) Name: %s Domain: %s Uses: %d OS:" |
| 283 | " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB" |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 284 | " session status: %d\t", |
Steve French | b8643e1 | 2005-04-28 22:41:07 -0700 | [diff] [blame] | 285 | i, ses->serverName, ses->serverDomain, |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 286 | ses->ses_count, ses->serverOS, ses->serverNOS, |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 287 | ses->capabilities, ses->status); |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 288 | } |
Long Li | 8339dd3 | 2017-11-07 01:54:55 -0700 | [diff] [blame] | 289 | if (server->rdma) |
| 290 | seq_printf(m, "RDMA\n\t"); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 291 | seq_printf(m, "TCP status: %d\n\tLocal Users To " |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 292 | "Server: %d SecMode: 0x%x Req On Wire: %d", |
| 293 | server->tcpStatus, server->srv_count, |
Pavel Shilovsky | fc40f9c | 2012-02-17 17:09:12 +0300 | [diff] [blame] | 294 | server->sec_mode, in_flight(server)); |
Steve French | 131afd0b | 2005-10-07 09:51:05 -0700 | [diff] [blame] | 295 | |
| 296 | #ifdef CONFIG_CIFS_STATS2 |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 297 | seq_printf(m, " In Send: %d In MaxReq Wait: %d", |
Steve French | 789e666 | 2011-08-09 18:44:44 +0000 | [diff] [blame] | 298 | atomic_read(&server->in_send), |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 299 | atomic_read(&server->num_waiters)); |
Steve French | 131afd0b | 2005-10-07 09:51:05 -0700 | [diff] [blame] | 300 | #endif |
| 301 | |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 302 | seq_puts(m, "\n\tShares:"); |
| 303 | j = 0; |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 304 | |
| 305 | seq_printf(m, "\n\t%d) IPC: ", j); |
| 306 | if (ses->tcon_ipc) |
| 307 | cifs_debug_tcon(m, ses->tcon_ipc); |
| 308 | else |
| 309 | seq_puts(m, "none\n"); |
| 310 | |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 311 | list_for_each(tmp3, &ses->tcon_list) { |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 312 | tcon = list_entry(tmp3, struct cifs_tcon, |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 313 | tcon_list); |
| 314 | ++j; |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 315 | seq_printf(m, "\n\t%d) ", j); |
| 316 | cifs_debug_tcon(m, tcon); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | seq_puts(m, "\n\tMIDs:\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | |
| 321 | spin_lock(&GlobalMid_Lock); |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 322 | list_for_each(tmp3, &server->pending_mid_q) { |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 323 | mid_entry = list_entry(tmp3, struct mid_q_entry, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | qhead); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 325 | seq_printf(m, "\tState: %d com: %d pid:" |
Pavel Shilovsky | 7c9421e | 2012-03-23 14:28:03 -0400 | [diff] [blame] | 326 | " %d cbdata: %p mid %llu\n", |
| 327 | mid_entry->mid_state, |
| 328 | le16_to_cpu(mid_entry->command), |
| 329 | mid_entry->pid, |
| 330 | mid_entry->callback_data, |
| 331 | mid_entry->mid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | } |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 333 | spin_unlock(&GlobalMid_Lock); |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 334 | |
| 335 | spin_lock(&ses->iface_lock); |
Steve French | 115d5d2 | 2018-06-14 21:59:31 -0500 | [diff] [blame] | 336 | if (ses->iface_count) |
| 337 | seq_printf(m, "\n\tServer interfaces: %zu\n", |
| 338 | ses->iface_count); |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 339 | for (j = 0; j < ses->iface_count; j++) { |
| 340 | seq_printf(m, "\t%d)\n", j); |
| 341 | cifs_dump_iface(m, &ses->iface_list[j]); |
| 342 | } |
| 343 | spin_unlock(&ses->iface_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | } |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 346 | spin_unlock(&cifs_tcp_ses_lock); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 347 | seq_putc(m, '\n'); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | /* BB add code to dump additional info such as TCP session info now */ |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 350 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | } |
| 352 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 353 | #ifdef CONFIG_CIFS_STATS |
| 354 | static ssize_t cifs_stats_proc_write(struct file *file, |
| 355 | const char __user *buffer, size_t count, loff_t *ppos) |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 356 | { |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 357 | bool bv; |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 358 | int rc; |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 359 | struct list_head *tmp1, *tmp2, *tmp3; |
| 360 | struct TCP_Server_Info *server; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 361 | struct cifs_ses *ses; |
| 362 | struct cifs_tcon *tcon; |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 363 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 364 | rc = kstrtobool_from_user(buffer, count, &bv); |
| 365 | if (rc == 0) { |
Steve French | 4498eed5 | 2005-12-03 13:58:57 -0800 | [diff] [blame] | 366 | #ifdef CONFIG_CIFS_STATS2 |
| 367 | atomic_set(&totBufAllocCount, 0); |
| 368 | atomic_set(&totSmBufAllocCount, 0); |
| 369 | #endif /* CONFIG_CIFS_STATS2 */ |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 370 | spin_lock(&cifs_tcp_ses_lock); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 371 | list_for_each(tmp1, &cifs_tcp_ses_list) { |
| 372 | server = list_entry(tmp1, struct TCP_Server_Info, |
| 373 | tcp_ses_list); |
Steve French | c2b3382 | 2008-11-17 03:57:13 +0000 | [diff] [blame] | 374 | list_for_each(tmp2, &server->smb_ses_list) { |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 375 | ses = list_entry(tmp2, struct cifs_ses, |
Steve French | c2b3382 | 2008-11-17 03:57:13 +0000 | [diff] [blame] | 376 | smb_ses_list); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 377 | list_for_each(tmp3, &ses->tcon_list) { |
| 378 | tcon = list_entry(tmp3, |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 379 | struct cifs_tcon, |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 380 | tcon_list); |
| 381 | atomic_set(&tcon->num_smbs_sent, 0); |
Pavel Shilovsky | 44c5818 | 2012-05-28 14:16:31 +0400 | [diff] [blame] | 382 | if (server->ops->clear_stats) |
| 383 | server->ops->clear_stats(tcon); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 384 | } |
| 385 | } |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 386 | } |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 387 | spin_unlock(&cifs_tcp_ses_lock); |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 388 | } else { |
| 389 | return rc; |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 390 | } |
| 391 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 392 | return count; |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 393 | } |
| 394 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 395 | static int cifs_stats_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 397 | int i; |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 398 | struct list_head *tmp1, *tmp2, *tmp3; |
| 399 | struct TCP_Server_Info *server; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 400 | struct cifs_ses *ses; |
| 401 | struct cifs_tcon *tcon; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 403 | seq_printf(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | "Resources in use\nCIFS Session: %d\n", |
| 405 | sesInfoAllocCount.counter); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 406 | seq_printf(m, "Share (unique mount targets): %d\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 407 | tconInfoAllocCount.counter); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 408 | seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n", |
Steve French | b8643e1 | 2005-04-28 22:41:07 -0700 | [diff] [blame] | 409 | bufAllocCount.counter, |
| 410 | cifs_min_rcv + tcpSesAllocCount.counter); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 411 | seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n", |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 412 | smBufAllocCount.counter, cifs_min_small); |
Steve French | 07475ff | 2005-12-03 14:11:37 -0800 | [diff] [blame] | 413 | #ifdef CONFIG_CIFS_STATS2 |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 414 | seq_printf(m, "Total Large %d Small %d Allocations\n", |
Steve French | 07475ff | 2005-12-03 14:11:37 -0800 | [diff] [blame] | 415 | atomic_read(&totBufAllocCount), |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 416 | atomic_read(&totSmBufAllocCount)); |
Steve French | 07475ff | 2005-12-03 14:11:37 -0800 | [diff] [blame] | 417 | #endif /* CONFIG_CIFS_STATS2 */ |
| 418 | |
Jeff Layton | 8097531 | 2011-01-11 07:24:02 -0500 | [diff] [blame] | 419 | seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount)); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 420 | seq_printf(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | "\n%d session %d share reconnects\n", |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 422 | tcpSesReconnectCount.counter, tconInfoReconnectCount.counter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 423 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 424 | seq_printf(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 425 | "Total vfs operations: %d maximum at one time: %d\n", |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 426 | GlobalCurrentXid, GlobalMaxActiveXid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 427 | |
| 428 | i = 0; |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 429 | spin_lock(&cifs_tcp_ses_lock); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 430 | list_for_each(tmp1, &cifs_tcp_ses_list) { |
| 431 | server = list_entry(tmp1, struct TCP_Server_Info, |
| 432 | tcp_ses_list); |
| 433 | list_for_each(tmp2, &server->smb_ses_list) { |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 434 | ses = list_entry(tmp2, struct cifs_ses, |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 435 | smb_ses_list); |
| 436 | list_for_each(tmp3, &ses->tcon_list) { |
| 437 | tcon = list_entry(tmp3, |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 438 | struct cifs_tcon, |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 439 | tcon_list); |
| 440 | i++; |
| 441 | seq_printf(m, "\n%d) %s", i, tcon->treeName); |
| 442 | if (tcon->need_reconnect) |
| 443 | seq_puts(m, "\tDISCONNECTED "); |
Pavel Shilovsky | 44c5818 | 2012-05-28 14:16:31 +0400 | [diff] [blame] | 444 | seq_printf(m, "\nSMBs: %d", |
| 445 | atomic_read(&tcon->num_smbs_sent)); |
| 446 | if (server->ops->print_stats) |
| 447 | server->ops->print_stats(m, tcon); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 448 | } |
| 449 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 450 | } |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 451 | spin_unlock(&cifs_tcp_ses_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 452 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 453 | seq_putc(m, '\n'); |
| 454 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 456 | |
| 457 | static int cifs_stats_proc_open(struct inode *inode, struct file *file) |
| 458 | { |
| 459 | return single_open(file, cifs_stats_proc_show, NULL); |
| 460 | } |
| 461 | |
| 462 | static const struct file_operations cifs_stats_proc_fops = { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 463 | .open = cifs_stats_proc_open, |
| 464 | .read = seq_read, |
| 465 | .llseek = seq_lseek, |
| 466 | .release = single_release, |
| 467 | .write = cifs_stats_proc_write, |
| 468 | }; |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 469 | #endif /* STATS */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 471 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 472 | #define PROC_FILE_DEFINE(name) \ |
| 473 | static ssize_t name##_write(struct file *file, const char __user *buffer, \ |
| 474 | size_t count, loff_t *ppos) \ |
| 475 | { \ |
| 476 | int rc; \ |
| 477 | rc = kstrtoint_from_user(buffer, count, 10, & name); \ |
| 478 | if (rc) \ |
| 479 | return rc; \ |
| 480 | return count; \ |
| 481 | } \ |
| 482 | static int name##_proc_show(struct seq_file *m, void *v) \ |
| 483 | { \ |
| 484 | seq_printf(m, "%d\n", name ); \ |
| 485 | return 0; \ |
| 486 | } \ |
| 487 | static int name##_open(struct inode *inode, struct file *file) \ |
| 488 | { \ |
| 489 | return single_open(file, name##_proc_show, NULL); \ |
| 490 | } \ |
| 491 | \ |
| 492 | static const struct file_operations cifs_##name##_proc_fops = { \ |
| 493 | .open = name##_open, \ |
| 494 | .read = seq_read, \ |
| 495 | .llseek = seq_lseek, \ |
| 496 | .release = single_release, \ |
| 497 | .write = name##_write, \ |
| 498 | } |
| 499 | |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 500 | PROC_FILE_DEFINE(rdma_readwrite_threshold); |
| 501 | PROC_FILE_DEFINE(smbd_max_frmr_depth); |
| 502 | PROC_FILE_DEFINE(smbd_keep_alive_interval); |
| 503 | PROC_FILE_DEFINE(smbd_max_receive_size); |
| 504 | PROC_FILE_DEFINE(smbd_max_fragmented_recv_size); |
| 505 | PROC_FILE_DEFINE(smbd_max_send_size); |
| 506 | PROC_FILE_DEFINE(smbd_send_credit_target); |
| 507 | PROC_FILE_DEFINE(smbd_receive_credit_max); |
| 508 | #endif |
| 509 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 510 | static struct proc_dir_entry *proc_fs_cifs; |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 511 | static const struct file_operations cifsFYI_proc_fops; |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 512 | static const struct file_operations cifs_lookup_cache_proc_fops; |
| 513 | static const struct file_operations traceSMB_proc_fops; |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 514 | static const struct file_operations cifs_security_flags_proc_fops; |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 515 | static const struct file_operations cifs_linux_ext_proc_fops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 516 | |
| 517 | void |
| 518 | cifs_proc_init(void) |
| 519 | { |
Alexey Dobriyan | 36a5aeb | 2008-04-29 01:01:42 -0700 | [diff] [blame] | 520 | proc_fs_cifs = proc_mkdir("fs/cifs", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 521 | if (proc_fs_cifs == NULL) |
| 522 | return; |
| 523 | |
Christoph Hellwig | 3f3942a | 2018-05-15 15:57:23 +0200 | [diff] [blame] | 524 | proc_create_single("DebugData", 0, proc_fs_cifs, |
| 525 | cifs_debug_data_proc_show); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | |
| 527 | #ifdef CONFIG_CIFS_STATS |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 528 | proc_create("Stats", 0644, proc_fs_cifs, &cifs_stats_proc_fops); |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 529 | #endif /* STATS */ |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 530 | proc_create("cifsFYI", 0644, proc_fs_cifs, &cifsFYI_proc_fops); |
| 531 | proc_create("traceSMB", 0644, proc_fs_cifs, &traceSMB_proc_fops); |
| 532 | proc_create("LinuxExtensionsEnabled", 0644, proc_fs_cifs, |
Steve French | 99b1f5b | 2008-07-24 02:37:45 +0000 | [diff] [blame] | 533 | &cifs_linux_ext_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 534 | proc_create("SecurityFlags", 0644, proc_fs_cifs, |
Steve French | 99b1f5b | 2008-07-24 02:37:45 +0000 | [diff] [blame] | 535 | &cifs_security_flags_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 536 | proc_create("LookupCacheEnabled", 0644, proc_fs_cifs, |
Steve French | 99b1f5b | 2008-07-24 02:37:45 +0000 | [diff] [blame] | 537 | &cifs_lookup_cache_proc_fops); |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 538 | #ifdef CONFIG_CIFS_SMB_DIRECT |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 539 | proc_create("rdma_readwrite_threshold", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 540 | &cifs_rdma_readwrite_threshold_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 541 | proc_create("smbd_max_frmr_depth", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 542 | &cifs_smbd_max_frmr_depth_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 543 | proc_create("smbd_keep_alive_interval", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 544 | &cifs_smbd_keep_alive_interval_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 545 | proc_create("smbd_max_receive_size", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 546 | &cifs_smbd_max_receive_size_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 547 | proc_create("smbd_max_fragmented_recv_size", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 548 | &cifs_smbd_max_fragmented_recv_size_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 549 | proc_create("smbd_max_send_size", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 550 | &cifs_smbd_max_send_size_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 551 | proc_create("smbd_send_credit_target", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 552 | &cifs_smbd_send_credit_target_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 553 | proc_create("smbd_receive_credit_max", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 554 | &cifs_smbd_receive_credit_max_proc_fops); |
| 555 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | } |
| 557 | |
| 558 | void |
| 559 | cifs_proc_clean(void) |
| 560 | { |
| 561 | if (proc_fs_cifs == NULL) |
| 562 | return; |
| 563 | |
| 564 | remove_proc_entry("DebugData", proc_fs_cifs); |
| 565 | remove_proc_entry("cifsFYI", proc_fs_cifs); |
| 566 | remove_proc_entry("traceSMB", proc_fs_cifs); |
| 567 | #ifdef CONFIG_CIFS_STATS |
| 568 | remove_proc_entry("Stats", proc_fs_cifs); |
| 569 | #endif |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 570 | remove_proc_entry("SecurityFlags", proc_fs_cifs); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 571 | remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 572 | remove_proc_entry("LookupCacheEnabled", proc_fs_cifs); |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 573 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 574 | remove_proc_entry("rdma_readwrite_threshold", proc_fs_cifs); |
| 575 | remove_proc_entry("smbd_max_frmr_depth", proc_fs_cifs); |
| 576 | remove_proc_entry("smbd_keep_alive_interval", proc_fs_cifs); |
| 577 | remove_proc_entry("smbd_max_receive_size", proc_fs_cifs); |
| 578 | remove_proc_entry("smbd_max_fragmented_recv_size", proc_fs_cifs); |
| 579 | remove_proc_entry("smbd_max_send_size", proc_fs_cifs); |
| 580 | remove_proc_entry("smbd_send_credit_target", proc_fs_cifs); |
| 581 | remove_proc_entry("smbd_receive_credit_max", proc_fs_cifs); |
| 582 | #endif |
Alexey Dobriyan | 36a5aeb | 2008-04-29 01:01:42 -0700 | [diff] [blame] | 583 | remove_proc_entry("fs/cifs", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 584 | } |
| 585 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 586 | static int cifsFYI_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 588 | seq_printf(m, "%d\n", cifsFYI); |
| 589 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 591 | |
| 592 | static int cifsFYI_proc_open(struct inode *inode, struct file *file) |
| 593 | { |
| 594 | return single_open(file, cifsFYI_proc_show, NULL); |
| 595 | } |
| 596 | |
| 597 | static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer, |
| 598 | size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | { |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 600 | char c[2] = { '\0' }; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 601 | bool bv; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 602 | int rc; |
| 603 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 604 | rc = get_user(c[0], buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 605 | if (rc) |
| 606 | return rc; |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 607 | if (strtobool(c, &bv) == 0) |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 608 | cifsFYI = bv; |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 609 | else if ((c[0] > '1') && (c[0] <= '9')) |
| 610 | cifsFYI = (int) (c[0] - '0'); /* see cifs_debug.h for meanings */ |
Ronnie Sahlberg | 25ad1cb | 2018-05-24 09:53:39 +1000 | [diff] [blame] | 611 | else |
| 612 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 613 | |
| 614 | return count; |
| 615 | } |
| 616 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 617 | static const struct file_operations cifsFYI_proc_fops = { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 618 | .open = cifsFYI_proc_open, |
| 619 | .read = seq_read, |
| 620 | .llseek = seq_lseek, |
| 621 | .release = single_release, |
| 622 | .write = cifsFYI_proc_write, |
| 623 | }; |
| 624 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 625 | static int cifs_linux_ext_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 626 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 627 | seq_printf(m, "%d\n", linuxExtEnabled); |
| 628 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 629 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 630 | |
| 631 | static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file) |
| 632 | { |
| 633 | return single_open(file, cifs_linux_ext_proc_show, NULL); |
| 634 | } |
| 635 | |
| 636 | static ssize_t cifs_linux_ext_proc_write(struct file *file, |
| 637 | const char __user *buffer, size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 638 | { |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 639 | int rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 640 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 641 | rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 642 | if (rc) |
| 643 | return rc; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 644 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 645 | return count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 646 | } |
| 647 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 648 | static const struct file_operations cifs_linux_ext_proc_fops = { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 649 | .open = cifs_linux_ext_proc_open, |
| 650 | .read = seq_read, |
| 651 | .llseek = seq_lseek, |
| 652 | .release = single_release, |
| 653 | .write = cifs_linux_ext_proc_write, |
| 654 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 655 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 656 | static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 657 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 658 | seq_printf(m, "%d\n", lookupCacheEnabled); |
| 659 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 660 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 661 | |
| 662 | static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file) |
| 663 | { |
| 664 | return single_open(file, cifs_lookup_cache_proc_show, NULL); |
| 665 | } |
| 666 | |
| 667 | static ssize_t cifs_lookup_cache_proc_write(struct file *file, |
| 668 | const char __user *buffer, size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 669 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 670 | int rc; |
| 671 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 672 | rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 673 | if (rc) |
| 674 | return rc; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 675 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 676 | return count; |
| 677 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 678 | |
| 679 | static const struct file_operations cifs_lookup_cache_proc_fops = { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 680 | .open = cifs_lookup_cache_proc_open, |
| 681 | .read = seq_read, |
| 682 | .llseek = seq_lseek, |
| 683 | .release = single_release, |
| 684 | .write = cifs_lookup_cache_proc_write, |
| 685 | }; |
| 686 | |
| 687 | static int traceSMB_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 688 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 689 | seq_printf(m, "%d\n", traceSMB); |
| 690 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 691 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 692 | |
| 693 | static int traceSMB_proc_open(struct inode *inode, struct file *file) |
| 694 | { |
| 695 | return single_open(file, traceSMB_proc_show, NULL); |
| 696 | } |
| 697 | |
| 698 | static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer, |
| 699 | size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 700 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 701 | int rc; |
| 702 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 703 | rc = kstrtobool_from_user(buffer, count, &traceSMB); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 704 | if (rc) |
| 705 | return rc; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 706 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 707 | return count; |
| 708 | } |
| 709 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 710 | static const struct file_operations traceSMB_proc_fops = { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 711 | .open = traceSMB_proc_open, |
| 712 | .read = seq_read, |
| 713 | .llseek = seq_lseek, |
| 714 | .release = single_release, |
| 715 | .write = traceSMB_proc_write, |
| 716 | }; |
| 717 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 718 | static int cifs_security_flags_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 719 | { |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 720 | seq_printf(m, "0x%x\n", global_secflags); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 721 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 722 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 723 | |
| 724 | static int cifs_security_flags_proc_open(struct inode *inode, struct file *file) |
| 725 | { |
| 726 | return single_open(file, cifs_security_flags_proc_show, NULL); |
| 727 | } |
| 728 | |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 729 | /* |
| 730 | * Ensure that if someone sets a MUST flag, that we disable all other MAY |
| 731 | * flags except for the ones corresponding to the given MUST flag. If there are |
| 732 | * multiple MUST flags, then try to prefer more secure ones. |
| 733 | */ |
| 734 | static void |
| 735 | cifs_security_flags_handle_must_flags(unsigned int *flags) |
| 736 | { |
| 737 | unsigned int signflags = *flags & CIFSSEC_MUST_SIGN; |
| 738 | |
| 739 | if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5) |
| 740 | *flags = CIFSSEC_MUST_KRB5; |
| 741 | else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP) |
| 742 | *flags = CIFSSEC_MUST_NTLMSSP; |
| 743 | else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2) |
| 744 | *flags = CIFSSEC_MUST_NTLMV2; |
| 745 | else if ((*flags & CIFSSEC_MUST_NTLM) == CIFSSEC_MUST_NTLM) |
| 746 | *flags = CIFSSEC_MUST_NTLM; |
Niklas Cassel | 7a1ceba | 2015-01-22 14:16:34 +0100 | [diff] [blame] | 747 | else if (CIFSSEC_MUST_LANMAN && |
| 748 | (*flags & CIFSSEC_MUST_LANMAN) == CIFSSEC_MUST_LANMAN) |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 749 | *flags = CIFSSEC_MUST_LANMAN; |
Niklas Cassel | 7a1ceba | 2015-01-22 14:16:34 +0100 | [diff] [blame] | 750 | else if (CIFSSEC_MUST_PLNTXT && |
| 751 | (*flags & CIFSSEC_MUST_PLNTXT) == CIFSSEC_MUST_PLNTXT) |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 752 | *flags = CIFSSEC_MUST_PLNTXT; |
| 753 | |
| 754 | *flags |= signflags; |
| 755 | } |
| 756 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 757 | static ssize_t cifs_security_flags_proc_write(struct file *file, |
| 758 | const char __user *buffer, size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 759 | { |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 760 | int rc; |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 761 | unsigned int flags; |
| 762 | char flags_string[12]; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 763 | bool bv; |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 764 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 765 | if ((count < 1) || (count > 11)) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 766 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 767 | |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 768 | memset(flags_string, 0, 12); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 769 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 770 | if (copy_from_user(flags_string, buffer, count)) |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 771 | return -EFAULT; |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 772 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 773 | if (count < 3) { |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 774 | /* single char or single char followed by null */ |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 775 | if (strtobool(flags_string, &bv) == 0) { |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 776 | global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF; |
Steve French | a013689 | 2007-10-04 20:05:09 +0000 | [diff] [blame] | 777 | return count; |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 778 | } else if (!isdigit(flags_string[0])) { |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 779 | cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", |
| 780 | flags_string); |
Steve French | a013689 | 2007-10-04 20:05:09 +0000 | [diff] [blame] | 781 | return -EINVAL; |
| 782 | } |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 783 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 784 | |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 785 | /* else we have a number */ |
| 786 | rc = kstrtouint(flags_string, 0, &flags); |
| 787 | if (rc) { |
| 788 | cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", |
| 789 | flags_string); |
| 790 | return rc; |
| 791 | } |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 792 | |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 793 | cifs_dbg(FYI, "sec flags 0x%x\n", flags); |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 794 | |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 795 | if (flags == 0) { |
| 796 | cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string); |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 797 | return -EINVAL; |
| 798 | } |
| 799 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 800 | if (flags & ~CIFSSEC_MASK) { |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 801 | cifs_dbg(VFS, "Unsupported security flags: 0x%x\n", |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 802 | flags & ~CIFSSEC_MASK); |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 803 | return -EINVAL; |
| 804 | } |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 805 | |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 806 | cifs_security_flags_handle_must_flags(&flags); |
| 807 | |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 808 | /* flags look ok - update the global security flags for cifs module */ |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 809 | global_secflags = flags; |
| 810 | if (global_secflags & CIFSSEC_MUST_SIGN) { |
Steve French | 762e5ab | 2007-06-28 18:41:42 +0000 | [diff] [blame] | 811 | /* requiring signing implies signing is allowed */ |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 812 | global_secflags |= CIFSSEC_MAY_SIGN; |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 813 | cifs_dbg(FYI, "packet signing now required\n"); |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 814 | } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 815 | cifs_dbg(FYI, "packet signing disabled\n"); |
Steve French | 762e5ab | 2007-06-28 18:41:42 +0000 | [diff] [blame] | 816 | } |
| 817 | /* BB should we turn on MAY flags for other MUST options? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 818 | return count; |
| 819 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 820 | |
| 821 | static const struct file_operations cifs_security_flags_proc_fops = { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 822 | .open = cifs_security_flags_proc_open, |
| 823 | .read = seq_read, |
| 824 | .llseek = seq_lseek, |
| 825 | .release = single_release, |
| 826 | .write = cifs_security_flags_proc_write, |
| 827 | }; |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 828 | #else |
Steve French | e086fce | 2008-02-18 04:03:58 +0000 | [diff] [blame] | 829 | inline void cifs_proc_init(void) |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 830 | { |
| 831 | } |
| 832 | |
Steve French | e086fce | 2008-02-18 04:03:58 +0000 | [diff] [blame] | 833 | inline void cifs_proc_clean(void) |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 834 | { |
| 835 | } |
| 836 | #endif /* PROC_FS */ |