Thomas Gleixner | 1a59d1b8 | 2019-05-27 08:55:05 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | */ |
| 8 | #include <linux/fs.h> |
| 9 | #include <linux/string.h> |
| 10 | #include <linux/ctype.h> |
Christophe JAILLET | 9f5d1a8 | 2023-01-14 09:58:15 +0100 | [diff] [blame] | 11 | #include <linux/kstrtox.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include <linux/module.h> |
| 13 | #include <linux/proc_fs.h> |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 14 | #include <linux/uaccess.h> |
Enzo Matsumiya | 50e63d6 | 2023-06-09 18:29:59 -0300 | [diff] [blame] | 15 | #include <uapi/linux/ethtool.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | #include "cifspdu.h" |
| 17 | #include "cifsglob.h" |
| 18 | #include "cifsproto.h" |
| 19 | #include "cifs_debug.h" |
Steve French | 6c91d36 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 20 | #include "cifsfs.h" |
Aurelien Aptel | 94b0595a | 2021-03-18 13:52:59 +0100 | [diff] [blame] | 21 | #include "fs_context.h" |
Paulo Alcantara | 54be1f6 | 2018-11-14 16:01:21 -0200 | [diff] [blame] | 22 | #ifdef CONFIG_CIFS_DFS_UPCALL |
| 23 | #include "dfs_cache.h" |
| 24 | #endif |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 25 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 26 | #include "smbdirect.h" |
| 27 | #endif |
Samuel Cabrero | 20fab0d | 2020-11-30 19:02:53 +0100 | [diff] [blame] | 28 | #include "cifs_swn.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
| 30 | void |
| 31 | cifs_dump_mem(char *label, void *data, int length) |
| 32 | { |
Andy Shevchenko | 0b456f0 | 2014-08-27 16:49:44 +0300 | [diff] [blame] | 33 | 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] | 34 | print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 4, |
| 35 | data, length, true); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | } |
| 37 | |
Ronnie Sahlberg | 14547f7 | 2018-04-22 14:45:53 -0600 | [diff] [blame] | 38 | void cifs_dump_detail(void *buf, struct TCP_Server_Info *server) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 39 | { |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 40 | #ifdef CONFIG_CIFS_DEBUG2 |
Yu Zhe | 0827f71 | 2022-06-14 01:54:49 -0700 | [diff] [blame] | 41 | struct smb_hdr *smb = buf; |
Pavel Shilovsky | d4e4854 | 2012-03-23 14:28:02 -0400 | [diff] [blame] | 42 | |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 43 | cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d\n", |
| 44 | smb->Command, smb->Status.CifsError, |
| 45 | smb->Flags, smb->Flags2, smb->Mid, smb->Pid); |
Ronnie Sahlberg | 14547f7 | 2018-04-22 14:45:53 -0600 | [diff] [blame] | 46 | cifs_dbg(VFS, "smb buf %p len %u\n", smb, |
Enzo Matsumiya | 68ed144 | 2022-08-17 14:14:02 -0300 | [diff] [blame] | 47 | server->ops->calc_smb_size(smb)); |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 48 | #endif /* CONFIG_CIFS_DEBUG2 */ |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 49 | } |
| 50 | |
Steve French | ffdd6e4 | 2007-06-24 21:15:44 +0000 | [diff] [blame] | 51 | void cifs_dump_mids(struct TCP_Server_Info *server) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 52 | { |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 53 | #ifdef CONFIG_CIFS_DEBUG2 |
Steve French | ffdd6e4 | 2007-06-24 21:15:44 +0000 | [diff] [blame] | 54 | struct mid_q_entry *mid_entry; |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 55 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 56 | if (server == NULL) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 57 | return; |
| 58 | |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 59 | cifs_dbg(VFS, "Dump pending requests:\n"); |
Shyam Prasad N | d7d7a66 | 2022-07-27 14:49:56 -0500 | [diff] [blame] | 60 | spin_lock(&server->mid_lock); |
Baokun Li | a506ccb | 2021-06-17 19:36:40 +0800 | [diff] [blame] | 61 | list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 62 | cifs_dbg(VFS, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu\n", |
| 63 | mid_entry->mid_state, |
| 64 | le16_to_cpu(mid_entry->command), |
| 65 | mid_entry->pid, |
| 66 | mid_entry->callback_data, |
| 67 | mid_entry->mid); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 68 | #ifdef CONFIG_CIFS_STATS2 |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 69 | cifs_dbg(VFS, "IsLarge: %d buf: %p time rcv: %ld now: %ld\n", |
| 70 | mid_entry->large_buf, |
| 71 | mid_entry->resp_buf, |
| 72 | mid_entry->when_received, |
| 73 | jiffies); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 74 | #endif /* STATS2 */ |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 75 | cifs_dbg(VFS, "IsMult: %d IsEnd: %d\n", |
| 76 | mid_entry->multiRsp, mid_entry->multiEnd); |
Steve French | ad8b15f | 2008-08-08 21:10:16 +0000 | [diff] [blame] | 77 | if (mid_entry->resp_buf) { |
Steve French | 71992e62 | 2018-05-06 15:58:51 -0500 | [diff] [blame] | 78 | cifs_dump_detail(mid_entry->resp_buf, server); |
Steve French | ad8b15f | 2008-08-08 21:10:16 +0000 | [diff] [blame] | 79 | cifs_dump_mem("existing buf: ", |
| 80 | mid_entry->resp_buf, 62); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 81 | } |
| 82 | } |
Shyam Prasad N | d7d7a66 | 2022-07-27 14:49:56 -0500 | [diff] [blame] | 83 | spin_unlock(&server->mid_lock); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 84 | #endif /* CONFIG_CIFS_DEBUG2 */ |
Pavel Shilovsky | 8aa26f3 | 2012-05-17 13:25:35 +0400 | [diff] [blame] | 85 | } |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 86 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | #ifdef CONFIG_PROC_FS |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 88 | static void cifs_debug_tcon(struct seq_file *m, struct cifs_tcon *tcon) |
| 89 | { |
| 90 | __u32 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType); |
| 91 | |
Steve French | 68e1456 | 2022-09-21 14:05:53 -0500 | [diff] [blame] | 92 | seq_printf(m, "%s Mounts: %d ", tcon->tree_name, tcon->tc_count); |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 93 | if (tcon->nativeFileSystem) |
| 94 | seq_printf(m, "Type: %s ", tcon->nativeFileSystem); |
| 95 | seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x\n\tPathComponentMax: %d Status: %d", |
| 96 | le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics), |
| 97 | le32_to_cpu(tcon->fsAttrInfo.Attributes), |
| 98 | le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength), |
Steve French | fdf59eb | 2022-03-27 16:07:30 -0500 | [diff] [blame] | 99 | tcon->status); |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 100 | if (dev_type == FILE_DEVICE_DISK) |
| 101 | seq_puts(m, " type: DISK "); |
| 102 | else if (dev_type == FILE_DEVICE_CD_ROM) |
| 103 | seq_puts(m, " type: CDROM "); |
| 104 | else |
| 105 | seq_printf(m, " type: %d ", dev_type); |
Steve French | ab7b10c | 2019-03-12 01:29:03 -0500 | [diff] [blame] | 106 | |
| 107 | seq_printf(m, "Serial Number: 0x%x", tcon->vol_serial_number); |
| 108 | |
Steve French | ffd1ef1 | 2019-03-09 18:12:18 -0600 | [diff] [blame] | 109 | if ((tcon->seal) || |
| 110 | (tcon->ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) || |
| 111 | (tcon->share_flags & SHI1005_FLAGS_ENCRYPT_DATA)) |
Steve French | 8b4dd44 | 2023-05-23 20:25:47 -0500 | [diff] [blame] | 112 | seq_puts(m, " encrypted"); |
Steve French | 5c5a41be | 2018-05-30 17:11:55 -0500 | [diff] [blame] | 113 | if (tcon->nocase) |
| 114 | seq_printf(m, " nocase"); |
Steve French | ede2e52 | 2018-01-31 14:34:37 -0600 | [diff] [blame] | 115 | if (tcon->unix_ext) |
| 116 | seq_printf(m, " POSIX Extensions"); |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 117 | if (tcon->ses->server->ops->dump_share_caps) |
| 118 | tcon->ses->server->ops->dump_share_caps(m, tcon); |
Samuel Cabrero | 20fab0d | 2020-11-30 19:02:53 +0100 | [diff] [blame] | 119 | if (tcon->use_witness) |
| 120 | seq_puts(m, " Witness"); |
Steve French | 5283225 | 2022-05-23 23:17:12 -0500 | [diff] [blame] | 121 | if (tcon->broken_sparse_sup) |
| 122 | seq_puts(m, " nosparse"); |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 123 | if (tcon->need_reconnect) |
| 124 | seq_puts(m, "\tDISCONNECTED "); |
Paulo Alcantara | 3ae872d | 2023-06-26 16:04:17 -0300 | [diff] [blame] | 125 | spin_lock(&tcon->tc_lock); |
| 126 | if (tcon->origin_fullpath) { |
| 127 | seq_printf(m, "\n\tDFS origin fullpath: %s", |
| 128 | tcon->origin_fullpath); |
| 129 | } |
| 130 | spin_unlock(&tcon->tc_lock); |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 131 | seq_putc(m, '\n'); |
| 132 | } |
| 133 | |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 134 | static void |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 135 | cifs_dump_channel(struct seq_file *m, int i, struct cifs_chan *chan) |
| 136 | { |
| 137 | struct TCP_Server_Info *server = chan->server; |
| 138 | |
Shyam Prasad N | 0c51cc6 | 2023-10-13 09:25:30 +0000 | [diff] [blame] | 139 | if (!server) { |
| 140 | seq_printf(m, "\n\n\t\tChannel: %d DISABLED", i+1); |
| 141 | return; |
| 142 | } |
| 143 | |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 144 | seq_printf(m, "\n\n\t\tChannel: %d ConnectionId: 0x%llx" |
Shyam Prasad N | 2a44b389 | 2023-06-09 17:46:55 +0000 | [diff] [blame] | 145 | "\n\t\tNumber of credits: %d,%d,%d Dialect 0x%x" |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 146 | "\n\t\tTCP status: %d Instance: %d" |
| 147 | "\n\t\tLocal Users To Server: %d SecMode: 0x%x Req On Wire: %d" |
| 148 | "\n\t\tIn Send: %d In MaxReq Wait: %d", |
| 149 | i+1, server->conn_id, |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 150 | server->credits, |
Shyam Prasad N | 2a44b389 | 2023-06-09 17:46:55 +0000 | [diff] [blame] | 151 | server->echo_credits, |
| 152 | server->oplock_credits, |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 153 | server->dialect, |
| 154 | server->tcpStatus, |
| 155 | server->reconnect_instance, |
| 156 | server->srv_count, |
| 157 | server->sec_mode, |
| 158 | in_flight(server), |
| 159 | atomic_read(&server->in_send), |
| 160 | atomic_read(&server->num_waiters)); |
Steve French | 7b38f6d | 2023-08-10 21:41:03 -0500 | [diff] [blame] | 161 | #ifdef CONFIG_NET_NS |
| 162 | if (server->net) |
| 163 | seq_printf(m, " Net namespace: %u ", server->net->ns.inum); |
| 164 | #endif /* NET_NS */ |
| 165 | |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 166 | } |
| 167 | |
Enzo Matsumiya | 50e63d6 | 2023-06-09 18:29:59 -0300 | [diff] [blame] | 168 | static inline const char *smb_speed_to_str(size_t bps) |
| 169 | { |
| 170 | size_t mbps = bps / 1000 / 1000; |
| 171 | |
| 172 | switch (mbps) { |
| 173 | case SPEED_10: |
| 174 | return "10Mbps"; |
| 175 | case SPEED_100: |
| 176 | return "100Mbps"; |
| 177 | case SPEED_1000: |
| 178 | return "1Gbps"; |
| 179 | case SPEED_2500: |
| 180 | return "2.5Gbps"; |
| 181 | case SPEED_5000: |
| 182 | return "5Gbps"; |
| 183 | case SPEED_10000: |
| 184 | return "10Gbps"; |
| 185 | case SPEED_14000: |
| 186 | return "14Gbps"; |
| 187 | case SPEED_20000: |
| 188 | return "20Gbps"; |
| 189 | case SPEED_25000: |
| 190 | return "25Gbps"; |
| 191 | case SPEED_40000: |
| 192 | return "40Gbps"; |
| 193 | case SPEED_50000: |
| 194 | return "50Gbps"; |
| 195 | case SPEED_56000: |
| 196 | return "56Gbps"; |
| 197 | case SPEED_100000: |
| 198 | return "100Gbps"; |
| 199 | case SPEED_200000: |
| 200 | return "200Gbps"; |
| 201 | case SPEED_400000: |
| 202 | return "400Gbps"; |
| 203 | case SPEED_800000: |
| 204 | return "800Gbps"; |
| 205 | default: |
| 206 | return "Unknown"; |
| 207 | } |
| 208 | } |
| 209 | |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 210 | static void |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 211 | cifs_dump_iface(struct seq_file *m, struct cifs_server_iface *iface) |
| 212 | { |
| 213 | struct sockaddr_in *ipv4 = (struct sockaddr_in *)&iface->sockaddr; |
| 214 | struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&iface->sockaddr; |
| 215 | |
Enzo Matsumiya | 50e63d6 | 2023-06-09 18:29:59 -0300 | [diff] [blame] | 216 | seq_printf(m, "\tSpeed: %s\n", smb_speed_to_str(iface->speed)); |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 217 | seq_puts(m, "\t\tCapabilities: "); |
| 218 | if (iface->rdma_capable) |
| 219 | seq_puts(m, "rdma "); |
| 220 | if (iface->rss_capable) |
| 221 | seq_puts(m, "rss "); |
Enzo Matsumiya | 50e63d6 | 2023-06-09 18:29:59 -0300 | [diff] [blame] | 222 | if (!iface->rdma_capable && !iface->rss_capable) |
| 223 | seq_puts(m, "None"); |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 224 | seq_putc(m, '\n'); |
| 225 | if (iface->sockaddr.ss_family == AF_INET) |
| 226 | seq_printf(m, "\t\tIPv4: %pI4\n", &ipv4->sin_addr); |
| 227 | else if (iface->sockaddr.ss_family == AF_INET6) |
| 228 | seq_printf(m, "\t\tIPv6: %pI6\n", &ipv6->sin6_addr); |
Shyam Prasad N | aa45dad | 2022-01-01 12:50:21 +0000 | [diff] [blame] | 229 | if (!iface->is_active) |
| 230 | seq_puts(m, "\t\t[for-cleanup]\n"); |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 231 | } |
| 232 | |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 233 | static int cifs_debug_files_proc_show(struct seq_file *m, void *v) |
| 234 | { |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 235 | struct TCP_Server_Info *server; |
| 236 | struct cifs_ses *ses; |
| 237 | struct cifs_tcon *tcon; |
| 238 | struct cifsFileInfo *cfile; |
| 239 | |
| 240 | seq_puts(m, "# Version:1\n"); |
| 241 | seq_puts(m, "# Format:\n"); |
Shyam Prasad N | 175b54a | 2023-03-13 12:17:34 +0000 | [diff] [blame] | 242 | seq_puts(m, "# <tree id> <ses id> <persistent fid> <flags> <count> <pid> <uid>"); |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 243 | #ifdef CONFIG_CIFS_DEBUG2 |
| 244 | seq_printf(m, " <filename> <mid>\n"); |
| 245 | #else |
| 246 | seq_printf(m, " <filename>\n"); |
| 247 | #endif /* CIFS_DEBUG2 */ |
| 248 | spin_lock(&cifs_tcp_ses_lock); |
Baokun Li | a506ccb | 2021-06-17 19:36:40 +0800 | [diff] [blame] | 249 | list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) { |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 250 | list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) { |
| 251 | list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 252 | spin_lock(&tcon->open_file_lock); |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 253 | list_for_each_entry(cfile, &tcon->openFileList, tlist) { |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 254 | seq_printf(m, |
Shyam Prasad N | 175b54a | 2023-03-13 12:17:34 +0000 | [diff] [blame] | 255 | "0x%x 0x%llx 0x%llx 0x%x %d %d %d %pd", |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 256 | tcon->tid, |
Shyam Prasad N | 175b54a | 2023-03-13 12:17:34 +0000 | [diff] [blame] | 257 | ses->Suid, |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 258 | cfile->fid.persistent_fid, |
| 259 | cfile->f_flags, |
| 260 | cfile->count, |
| 261 | cfile->pid, |
| 262 | from_kuid(&init_user_ns, cfile->uid), |
Al Viro | b9e4666 | 2021-01-06 21:53:52 -0500 | [diff] [blame] | 263 | cfile->dentry); |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 264 | #ifdef CONFIG_CIFS_DEBUG2 |
Paulo Alcantara | bf1bc694 | 2021-03-08 12:00:47 -0300 | [diff] [blame] | 265 | seq_printf(m, " %llu\n", cfile->fid.mid); |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 266 | #else |
| 267 | seq_printf(m, "\n"); |
| 268 | #endif /* CIFS_DEBUG2 */ |
| 269 | } |
| 270 | spin_unlock(&tcon->open_file_lock); |
| 271 | } |
| 272 | } |
| 273 | } |
| 274 | spin_unlock(&cifs_tcp_ses_lock); |
| 275 | seq_putc(m, '\n'); |
| 276 | return 0; |
| 277 | } |
| 278 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 279 | 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] | 280 | { |
Steve French | ffdd6e4 | 2007-06-24 21:15:44 +0000 | [diff] [blame] | 281 | struct mid_q_entry *mid_entry; |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 282 | struct TCP_Server_Info *server; |
Shyam Prasad N | d12bc6d | 2023-03-13 11:09:12 +0000 | [diff] [blame] | 283 | struct TCP_Server_Info *chan_server; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 284 | struct cifs_ses *ses; |
| 285 | struct cifs_tcon *tcon; |
Shyam Prasad N | aa45dad | 2022-01-01 12:50:21 +0000 | [diff] [blame] | 286 | struct cifs_server_iface *iface; |
Shyam Prasad N | a6d8fb5 | 2022-12-26 11:24:56 +0000 | [diff] [blame] | 287 | size_t iface_weight = 0, iface_min_speed = 0; |
| 288 | struct cifs_server_iface *last_iface = NULL; |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 289 | int c, i, j; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 291 | seq_puts(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | "Display Internal CIFS Data Structures for Debugging\n" |
| 293 | "---------------------------------------------------\n"); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 294 | seq_printf(m, "CIFS Version %s\n", CIFS_VERSION); |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 295 | seq_printf(m, "Features:"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 296 | #ifdef CONFIG_CIFS_DFS_UPCALL |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 297 | seq_printf(m, " DFS"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 298 | #endif |
| 299 | #ifdef CONFIG_CIFS_FSCACHE |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 300 | seq_printf(m, ",FSCACHE"); |
| 301 | #endif |
| 302 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 303 | seq_printf(m, ",SMB_DIRECT"); |
| 304 | #endif |
| 305 | #ifdef CONFIG_CIFS_STATS2 |
| 306 | seq_printf(m, ",STATS2"); |
Steve French | d258650 | 2018-08-01 22:34:04 -0500 | [diff] [blame] | 307 | #else |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 308 | seq_printf(m, ",STATS"); |
| 309 | #endif |
| 310 | #ifdef CONFIG_CIFS_DEBUG2 |
| 311 | seq_printf(m, ",DEBUG2"); |
| 312 | #elif defined(CONFIG_CIFS_DEBUG) |
| 313 | seq_printf(m, ",DEBUG"); |
| 314 | #endif |
| 315 | #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY |
| 316 | seq_printf(m, ",ALLOW_INSECURE_LEGACY"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 317 | #endif |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 318 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 319 | seq_printf(m, ",CIFS_POSIX"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 320 | #endif |
| 321 | #ifdef CONFIG_CIFS_UPCALL |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 322 | seq_printf(m, ",UPCALL(SPNEGO)"); |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 323 | #endif |
| 324 | #ifdef CONFIG_CIFS_XATTR |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 325 | seq_printf(m, ",XATTR"); |
Jeff Layton | ca40b71 | 2011-01-07 11:30:29 -0500 | [diff] [blame] | 326 | #endif |
Steve French | 950132a | 2018-06-28 18:46:40 -0500 | [diff] [blame] | 327 | seq_printf(m, ",ACL"); |
Samuel Cabrero | 20fab0d | 2020-11-30 19:02:53 +0100 | [diff] [blame] | 328 | #ifdef CONFIG_CIFS_SWN_UPCALL |
| 329 | seq_puts(m, ",WITNESS"); |
| 330 | #endif |
Suresh Jayaraman | f579903 | 2010-07-30 18:25:56 +0530 | [diff] [blame] | 331 | seq_putc(m, '\n'); |
Ronnie Sahlberg | a5f1a81 | 2019-01-24 16:19:31 +1000 | [diff] [blame] | 332 | seq_printf(m, "CIFSMaxBufSize: %d\n", CIFSMaxBufSize); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 333 | seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 335 | seq_printf(m, "\nServers: "); |
| 336 | |
| 337 | c = 0; |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 338 | spin_lock(&cifs_tcp_ses_lock); |
Baokun Li | a506ccb | 2021-06-17 19:36:40 +0800 | [diff] [blame] | 339 | list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) { |
Shyam Prasad N | 0f2b305 | 2021-07-19 11:26:24 +0000 | [diff] [blame] | 340 | /* channel info will be printed as a part of sessions below */ |
Steve French | b3773b1 | 2023-08-24 23:44:05 -0500 | [diff] [blame] | 341 | if (SERVER_IS_CHAN(server)) |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 342 | continue; |
| 343 | |
| 344 | c++; |
| 345 | seq_printf(m, "\n%d) ConnectionId: 0x%llx ", |
| 346 | c, server->conn_id); |
| 347 | |
Paulo Alcantara | 90c49fc | 2023-04-21 15:52:32 -0300 | [diff] [blame] | 348 | spin_lock(&server->srv_lock); |
Steve French | 40f077a | 2021-02-21 23:00:46 -0600 | [diff] [blame] | 349 | if (server->hostname) |
| 350 | seq_printf(m, "Hostname: %s ", server->hostname); |
Shyam Prasad N | 380958a | 2023-06-27 12:09:43 +0000 | [diff] [blame] | 351 | seq_printf(m, "\nClientGUID: %pUL", server->client_guid); |
Paulo Alcantara | 90c49fc | 2023-04-21 15:52:32 -0300 | [diff] [blame] | 352 | spin_unlock(&server->srv_lock); |
Long Li | 08a3b96 | 2017-11-22 17:38:48 -0700 | [diff] [blame] | 353 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 354 | if (!server->rdma) |
| 355 | goto skip_rdma; |
| 356 | |
Long Li | 14cc639 | 2019-10-16 13:51:50 -0700 | [diff] [blame] | 357 | if (!server->smbd_conn) { |
| 358 | seq_printf(m, "\nSMBDirect transport not available"); |
| 359 | goto skip_rdma; |
| 360 | } |
| 361 | |
Long Li | 08a3b96 | 2017-11-22 17:38:48 -0700 | [diff] [blame] | 362 | seq_printf(m, "\nSMBDirect (in hex) protocol version: %x " |
| 363 | "transport status: %x", |
| 364 | server->smbd_conn->protocol, |
| 365 | server->smbd_conn->transport_status); |
| 366 | seq_printf(m, "\nConn receive_credit_max: %x " |
| 367 | "send_credit_target: %x max_send_size: %x", |
| 368 | server->smbd_conn->receive_credit_max, |
| 369 | server->smbd_conn->send_credit_target, |
| 370 | server->smbd_conn->max_send_size); |
| 371 | seq_printf(m, "\nConn max_fragmented_recv_size: %x " |
| 372 | "max_fragmented_send_size: %x max_receive_size:%x", |
| 373 | server->smbd_conn->max_fragmented_recv_size, |
| 374 | server->smbd_conn->max_fragmented_send_size, |
| 375 | server->smbd_conn->max_receive_size); |
| 376 | seq_printf(m, "\nConn keep_alive_interval: %x " |
| 377 | "max_readwrite_size: %x rdma_readwrite_threshold: %x", |
| 378 | server->smbd_conn->keep_alive_interval, |
| 379 | server->smbd_conn->max_readwrite_size, |
| 380 | server->smbd_conn->rdma_readwrite_threshold); |
| 381 | seq_printf(m, "\nDebug count_get_receive_buffer: %x " |
| 382 | "count_put_receive_buffer: %x count_send_empty: %x", |
| 383 | server->smbd_conn->count_get_receive_buffer, |
| 384 | server->smbd_conn->count_put_receive_buffer, |
| 385 | server->smbd_conn->count_send_empty); |
| 386 | seq_printf(m, "\nRead Queue count_reassembly_queue: %x " |
| 387 | "count_enqueue_reassembly_queue: %x " |
| 388 | "count_dequeue_reassembly_queue: %x " |
| 389 | "fragment_reassembly_remaining: %x " |
| 390 | "reassembly_data_length: %x " |
| 391 | "reassembly_queue_length: %x", |
| 392 | server->smbd_conn->count_reassembly_queue, |
| 393 | server->smbd_conn->count_enqueue_reassembly_queue, |
| 394 | server->smbd_conn->count_dequeue_reassembly_queue, |
| 395 | server->smbd_conn->fragment_reassembly_remaining, |
| 396 | server->smbd_conn->reassembly_data_length, |
| 397 | server->smbd_conn->reassembly_queue_length); |
| 398 | seq_printf(m, "\nCurrent Credits send_credits: %x " |
| 399 | "receive_credits: %x receive_credit_target: %x", |
| 400 | atomic_read(&server->smbd_conn->send_credits), |
| 401 | atomic_read(&server->smbd_conn->receive_credits), |
| 402 | server->smbd_conn->receive_credit_target); |
Long Li | 072a14e | 2020-03-30 11:04:06 -0700 | [diff] [blame] | 403 | seq_printf(m, "\nPending send_pending: %x ", |
| 404 | atomic_read(&server->smbd_conn->send_pending)); |
Long Li | 08a3b96 | 2017-11-22 17:38:48 -0700 | [diff] [blame] | 405 | seq_printf(m, "\nReceive buffers count_receive_queue: %x " |
| 406 | "count_empty_packet_queue: %x", |
| 407 | server->smbd_conn->count_receive_queue, |
| 408 | server->smbd_conn->count_empty_packet_queue); |
| 409 | seq_printf(m, "\nMR responder_resources: %x " |
| 410 | "max_frmr_depth: %x mr_type: %x", |
| 411 | server->smbd_conn->responder_resources, |
| 412 | server->smbd_conn->max_frmr_depth, |
| 413 | server->smbd_conn->mr_type); |
| 414 | seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x", |
| 415 | atomic_read(&server->smbd_conn->mr_ready_count), |
| 416 | atomic_read(&server->smbd_conn->mr_used_count)); |
| 417 | skip_rdma: |
| 418 | #endif |
Shyam Prasad N | 2a44b389 | 2023-06-09 17:46:55 +0000 | [diff] [blame] | 419 | seq_printf(m, "\nNumber of credits: %d,%d,%d Dialect 0x%x", |
| 420 | server->credits, |
| 421 | server->echo_credits, |
| 422 | server->oplock_credits, |
| 423 | server->dialect); |
Steve French | 26ea888 | 2019-04-26 20:36:08 -0700 | [diff] [blame] | 424 | if (server->compress_algorithm == SMB3_COMPRESS_LZNT1) |
| 425 | seq_printf(m, " COMPRESS_LZNT1"); |
| 426 | else if (server->compress_algorithm == SMB3_COMPRESS_LZ77) |
| 427 | seq_printf(m, " COMPRESS_LZ77"); |
| 428 | else if (server->compress_algorithm == SMB3_COMPRESS_LZ77_HUFF) |
| 429 | seq_printf(m, " COMPRESS_LZ77_HUFF"); |
Steve French | ede2e52 | 2018-01-31 14:34:37 -0600 | [diff] [blame] | 430 | if (server->sign) |
| 431 | seq_printf(m, " signed"); |
Steve French | fcef0db | 2018-05-19 20:45:27 -0500 | [diff] [blame] | 432 | if (server->posix_ext_supported) |
| 433 | seq_printf(m, " posix"); |
Shyam Prasad N | c9f1c19 | 2021-11-06 11:31:53 +0000 | [diff] [blame] | 434 | if (server->nosharesock) |
| 435 | seq_printf(m, " nosharesock"); |
Steve French | 0fdfef9 | 2018-06-28 19:30:23 -0500 | [diff] [blame] | 436 | |
Shyam Prasad N | 5276869 | 2023-10-30 11:00:07 +0000 | [diff] [blame] | 437 | seq_printf(m, "\nServer capabilities: 0x%x", server->capabilities); |
| 438 | |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 439 | if (server->rdma) |
| 440 | seq_printf(m, "\nRDMA "); |
| 441 | seq_printf(m, "\nTCP status: %d Instance: %d" |
| 442 | "\nLocal Users To Server: %d SecMode: 0x%x Req On Wire: %d", |
| 443 | server->tcpStatus, |
| 444 | server->reconnect_instance, |
| 445 | server->srv_count, |
| 446 | server->sec_mode, in_flight(server)); |
Steve French | 7b38f6d | 2023-08-10 21:41:03 -0500 | [diff] [blame] | 447 | #ifdef CONFIG_NET_NS |
| 448 | if (server->net) |
| 449 | seq_printf(m, " Net namespace: %u ", server->net->ns.inum); |
| 450 | #endif /* NET_NS */ |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 451 | |
| 452 | seq_printf(m, "\nIn Send: %d In MaxReq Wait: %d", |
| 453 | atomic_read(&server->in_send), |
| 454 | atomic_read(&server->num_waiters)); |
Steve French | 7b38f6d | 2023-08-10 21:41:03 -0500 | [diff] [blame] | 455 | |
Paulo Alcantara | 3ae872d | 2023-06-26 16:04:17 -0300 | [diff] [blame] | 456 | if (server->leaf_fullpath) { |
| 457 | seq_printf(m, "\nDFS leaf full path: %s", |
| 458 | server->leaf_fullpath); |
Paulo Alcantara | a1c0d00 | 2022-11-17 13:23:49 -0300 | [diff] [blame] | 459 | } |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 460 | |
| 461 | seq_printf(m, "\n\n\tSessions: "); |
| 462 | i = 0; |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 463 | list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) { |
Paulo Alcantara | d328c09 | 2023-10-24 13:49:15 -0300 | [diff] [blame] | 464 | spin_lock(&ses->ses_lock); |
| 465 | if (ses->ses_status == SES_EXITING) { |
| 466 | spin_unlock(&ses->ses_lock); |
| 467 | continue; |
| 468 | } |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 469 | i++; |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 470 | if ((ses->serverDomain == NULL) || |
| 471 | (ses->serverOS == NULL) || |
| 472 | (ses->serverNOS == NULL)) { |
Steve French | 40f077a | 2021-02-21 23:00:46 -0600 | [diff] [blame] | 473 | seq_printf(m, "\n\t%d) Address: %s Uses: %d Capability: 0x%x\tSession Status: %d ", |
Steve French | b438fcf | 2021-02-20 19:24:11 -0600 | [diff] [blame] | 474 | i, ses->ip_addr, ses->ses_count, |
Shyam Prasad N | dd3cd87 | 2022-04-07 13:15:49 +0000 | [diff] [blame] | 475 | ses->capabilities, ses->ses_status); |
Steve French | 1fa089e | 2017-09-20 16:46:49 -0500 | [diff] [blame] | 476 | if (ses->session_flags & SMB2_SESSION_FLAG_IS_GUEST) |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 477 | seq_printf(m, "Guest "); |
Steve French | 1fa089e | 2017-09-20 16:46:49 -0500 | [diff] [blame] | 478 | else if (ses->session_flags & SMB2_SESSION_FLAG_IS_NULL) |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 479 | seq_printf(m, "Anonymous "); |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 480 | } else { |
| 481 | seq_printf(m, |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 482 | "\n\t%d) Name: %s Domain: %s Uses: %d OS: %s " |
| 483 | "\n\tNOS: %s\tCapability: 0x%x" |
| 484 | "\n\tSMB session status: %d ", |
Steve French | b438fcf | 2021-02-20 19:24:11 -0600 | [diff] [blame] | 485 | i, ses->ip_addr, ses->serverDomain, |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 486 | ses->ses_count, ses->serverOS, ses->serverNOS, |
Shyam Prasad N | dd3cd87 | 2022-04-07 13:15:49 +0000 | [diff] [blame] | 487 | ses->capabilities, ses->ses_status); |
Jeff Layton | 14fbf50 | 2008-11-14 13:53:46 -0500 | [diff] [blame] | 488 | } |
Paulo Alcantara | d328c09 | 2023-10-24 13:49:15 -0300 | [diff] [blame] | 489 | spin_unlock(&ses->ses_lock); |
Kenneth D'souza | 8e84a61 | 2020-06-04 21:14:41 +0530 | [diff] [blame] | 490 | |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 491 | seq_printf(m, "\n\tSecurity type: %s ", |
Kenneth D'souza | 0b0430c | 2020-06-09 10:12:10 +0530 | [diff] [blame] | 492 | get_security_type_str(server->ops->select_sectype(server, ses->sectype))); |
Kenneth D'souza | 8e84a61 | 2020-06-04 21:14:41 +0530 | [diff] [blame] | 493 | |
Steve French | b63a9de | 2019-05-08 22:41:37 -0500 | [diff] [blame] | 494 | /* dump session id helpful for use with network trace */ |
| 495 | seq_printf(m, " SessionId: 0x%llx", ses->Suid); |
Steve French | 8b4dd44 | 2023-05-23 20:25:47 -0500 | [diff] [blame] | 496 | if (ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) { |
Steve French | ffd1ef1 | 2019-03-09 18:12:18 -0600 | [diff] [blame] | 497 | seq_puts(m, " encrypted"); |
Steve French | 8b4dd44 | 2023-05-23 20:25:47 -0500 | [diff] [blame] | 498 | /* can help in debugging to show encryption type */ |
| 499 | if (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM) |
| 500 | seq_puts(m, "(gcm256)"); |
| 501 | } |
Steve French | ffd1ef1 | 2019-03-09 18:12:18 -0600 | [diff] [blame] | 502 | if (ses->sign) |
| 503 | seq_puts(m, " signed"); |
Steve French | 131afd0b | 2005-10-07 09:51:05 -0700 | [diff] [blame] | 504 | |
Paul Aurich | aadd69ca | 2020-06-26 12:58:04 -0700 | [diff] [blame] | 505 | seq_printf(m, "\n\tUser: %d Cred User: %d", |
| 506 | from_kuid(&init_user_ns, ses->linux_uid), |
| 507 | from_kuid(&init_user_ns, ses->cred_uid)); |
| 508 | |
Paulo Alcantara | f446a63 | 2023-03-14 20:32:55 -0300 | [diff] [blame] | 509 | if (ses->dfs_root_ses) { |
| 510 | seq_printf(m, "\n\tDFS root session id: 0x%llx", |
| 511 | ses->dfs_root_ses->Suid); |
| 512 | } |
| 513 | |
Shyam Prasad N | 724244c | 2021-07-19 10:54:46 +0000 | [diff] [blame] | 514 | spin_lock(&ses->chan_lock); |
Shyam Prasad N | 66eb0c6 | 2021-07-19 14:01:32 +0000 | [diff] [blame] | 515 | if (CIFS_CHAN_NEEDS_RECONNECT(ses, 0)) |
| 516 | seq_puts(m, "\tPrimary channel: DISCONNECTED "); |
Shyam Prasad N | 5752bf6 | 2022-04-08 13:31:37 +0000 | [diff] [blame] | 517 | if (CIFS_CHAN_IN_RECONNECT(ses, 0)) |
| 518 | seq_puts(m, "\t[RECONNECTING] "); |
Shyam Prasad N | 66eb0c6 | 2021-07-19 14:01:32 +0000 | [diff] [blame] | 519 | |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 520 | if (ses->chan_count > 1) { |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 521 | seq_printf(m, "\n\n\tExtra Channels: %zu ", |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 522 | ses->chan_count-1); |
Shyam Prasad N | 66eb0c6 | 2021-07-19 14:01:32 +0000 | [diff] [blame] | 523 | for (j = 1; j < ses->chan_count; j++) { |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 524 | cifs_dump_channel(m, j, &ses->chans[j]); |
Shyam Prasad N | 66eb0c6 | 2021-07-19 14:01:32 +0000 | [diff] [blame] | 525 | if (CIFS_CHAN_NEEDS_RECONNECT(ses, j)) |
| 526 | seq_puts(m, "\tDISCONNECTED "); |
Shyam Prasad N | 5752bf6 | 2022-04-08 13:31:37 +0000 | [diff] [blame] | 527 | if (CIFS_CHAN_IN_RECONNECT(ses, j)) |
| 528 | seq_puts(m, "\t[RECONNECTING] "); |
Shyam Prasad N | 66eb0c6 | 2021-07-19 14:01:32 +0000 | [diff] [blame] | 529 | } |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 530 | } |
Shyam Prasad N | 724244c | 2021-07-19 10:54:46 +0000 | [diff] [blame] | 531 | spin_unlock(&ses->chan_lock); |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 532 | |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 533 | seq_puts(m, "\n\n\tShares: "); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 534 | j = 0; |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 535 | |
| 536 | seq_printf(m, "\n\t%d) IPC: ", j); |
| 537 | if (ses->tcon_ipc) |
| 538 | cifs_debug_tcon(m, ses->tcon_ipc); |
| 539 | else |
| 540 | seq_puts(m, "none\n"); |
| 541 | |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 542 | list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 543 | ++j; |
Aurelien Aptel | 02cf590 | 2018-01-24 13:46:12 +0100 | [diff] [blame] | 544 | seq_printf(m, "\n\t%d) ", j); |
| 545 | cifs_debug_tcon(m, tcon); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 546 | } |
| 547 | |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 548 | spin_lock(&ses->iface_lock); |
Steve French | 115d5d2 | 2018-06-14 21:59:31 -0500 | [diff] [blame] | 549 | if (ses->iface_count) |
Shyam Prasad N | 05844bd | 2022-12-23 10:41:25 +0000 | [diff] [blame] | 550 | seq_printf(m, "\n\n\tServer interfaces: %zu" |
| 551 | "\tLast updated: %lu seconds ago", |
| 552 | ses->iface_count, |
| 553 | (jiffies - ses->iface_last_update) / HZ); |
Shyam Prasad N | a6d8fb5 | 2022-12-26 11:24:56 +0000 | [diff] [blame] | 554 | |
| 555 | last_iface = list_last_entry(&ses->iface_list, |
| 556 | struct cifs_server_iface, |
| 557 | iface_head); |
| 558 | iface_min_speed = last_iface->speed; |
| 559 | |
Shyam Prasad N | aa45dad | 2022-01-01 12:50:21 +0000 | [diff] [blame] | 560 | j = 0; |
| 561 | list_for_each_entry(iface, &ses->iface_list, |
| 562 | iface_head) { |
| 563 | seq_printf(m, "\n\t%d)", ++j); |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 564 | cifs_dump_iface(m, iface); |
Shyam Prasad N | a6d8fb5 | 2022-12-26 11:24:56 +0000 | [diff] [blame] | 565 | |
| 566 | iface_weight = iface->speed / iface_min_speed; |
| 567 | seq_printf(m, "\t\tWeight (cur,total): (%zu,%zu)" |
| 568 | "\n\t\tAllocated channels: %u\n", |
| 569 | iface->weight_fulfilled, |
| 570 | iface_weight, |
| 571 | iface->num_channels); |
| 572 | |
Aurelien Aptel | 8515092 | 2019-11-20 17:15:58 +0100 | [diff] [blame] | 573 | if (is_ses_using_iface(ses, iface)) |
| 574 | seq_puts(m, "\t\t[CONNECTED]\n"); |
Aurelien Aptel | bc0fe8b | 2018-06-14 15:43:20 +0200 | [diff] [blame] | 575 | } |
| 576 | spin_unlock(&ses->iface_lock); |
Shyam Prasad N | d12bc6d | 2023-03-13 11:09:12 +0000 | [diff] [blame] | 577 | |
| 578 | seq_puts(m, "\n\n\tMIDs: "); |
| 579 | spin_lock(&ses->chan_lock); |
| 580 | for (j = 0; j < ses->chan_count; j++) { |
| 581 | chan_server = ses->chans[j].server; |
| 582 | if (!chan_server) |
| 583 | continue; |
| 584 | |
| 585 | if (list_empty(&chan_server->pending_mid_q)) |
| 586 | continue; |
| 587 | |
| 588 | seq_printf(m, "\n\tServer ConnectionId: 0x%llx", |
| 589 | chan_server->conn_id); |
| 590 | spin_lock(&chan_server->mid_lock); |
| 591 | list_for_each_entry(mid_entry, &chan_server->pending_mid_q, qhead) { |
| 592 | seq_printf(m, "\n\t\tState: %d com: %d pid: %d cbdata: %p mid %llu", |
| 593 | mid_entry->mid_state, |
| 594 | le16_to_cpu(mid_entry->command), |
| 595 | mid_entry->pid, |
| 596 | mid_entry->callback_data, |
| 597 | mid_entry->mid); |
| 598 | } |
| 599 | spin_unlock(&chan_server->mid_lock); |
| 600 | } |
| 601 | spin_unlock(&ses->chan_lock); |
| 602 | seq_puts(m, "\n--\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 603 | } |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 604 | if (i == 0) |
| 605 | seq_printf(m, "\n\t\t[NONE]"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 606 | } |
Shyam Prasad N | 03e9bb1a | 2021-02-03 23:27:52 -0800 | [diff] [blame] | 607 | if (c == 0) |
| 608 | seq_printf(m, "\n\t[NONE]"); |
| 609 | |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 610 | spin_unlock(&cifs_tcp_ses_lock); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 611 | seq_putc(m, '\n'); |
Samuel Cabrero | 20fab0d | 2020-11-30 19:02:53 +0100 | [diff] [blame] | 612 | cifs_swn_dump(m); |
Aurelien Aptel | b7fd0fa | 2021-04-09 16:31:37 +0200 | [diff] [blame] | 613 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 614 | /* 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] | 615 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 616 | } |
| 617 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 618 | static ssize_t cifs_stats_proc_write(struct file *file, |
| 619 | const char __user *buffer, size_t count, loff_t *ppos) |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 620 | { |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 621 | bool bv; |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 622 | int rc; |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 623 | struct TCP_Server_Info *server; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 624 | struct cifs_ses *ses; |
| 625 | struct cifs_tcon *tcon; |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 626 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 627 | rc = kstrtobool_from_user(buffer, count, &bv); |
| 628 | if (rc == 0) { |
Steve French | 4498eed5 | 2005-12-03 13:58:57 -0800 | [diff] [blame] | 629 | #ifdef CONFIG_CIFS_STATS2 |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 630 | int i; |
| 631 | |
Steve French | c2c17dd | 2022-07-15 23:45:45 -0500 | [diff] [blame] | 632 | atomic_set(&total_buf_alloc_count, 0); |
| 633 | atomic_set(&total_small_buf_alloc_count, 0); |
Steve French | 4498eed5 | 2005-12-03 13:58:57 -0800 | [diff] [blame] | 634 | #endif /* CONFIG_CIFS_STATS2 */ |
Steve French | 2c887635 | 2018-09-15 23:04:41 -0500 | [diff] [blame] | 635 | atomic_set(&tcpSesReconnectCount, 0); |
| 636 | atomic_set(&tconInfoReconnectCount, 0); |
| 637 | |
Steve French | c281bc0 | 2018-08-01 00:56:12 -0500 | [diff] [blame] | 638 | spin_lock(&GlobalMid_Lock); |
| 639 | GlobalMaxActiveXid = 0; |
| 640 | GlobalCurrentXid = 0; |
| 641 | spin_unlock(&GlobalMid_Lock); |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 642 | spin_lock(&cifs_tcp_ses_lock); |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 643 | list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) { |
Steve French | 1b63f18 | 2019-09-09 22:57:11 -0500 | [diff] [blame] | 644 | server->max_in_flight = 0; |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 645 | #ifdef CONFIG_CIFS_STATS2 |
Steve French | 433b8dd | 2019-03-26 13:53:21 -0500 | [diff] [blame] | 646 | for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) { |
| 647 | atomic_set(&server->num_cmds[i], 0); |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 648 | atomic_set(&server->smb2slowcmd[i], 0); |
Steve French | 433b8dd | 2019-03-26 13:53:21 -0500 | [diff] [blame] | 649 | server->time_per_cmd[i] = 0; |
| 650 | server->slowest_cmd[i] = 0; |
| 651 | server->fastest_cmd[0] = 0; |
| 652 | } |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 653 | #endif /* CONFIG_CIFS_STATS2 */ |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 654 | list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) { |
| 655 | list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 656 | atomic_set(&tcon->num_smbs_sent, 0); |
Steve French | c281bc0 | 2018-08-01 00:56:12 -0500 | [diff] [blame] | 657 | spin_lock(&tcon->stat_lock); |
| 658 | tcon->bytes_read = 0; |
| 659 | tcon->bytes_written = 0; |
| 660 | spin_unlock(&tcon->stat_lock); |
Pavel Shilovsky | 44c5818 | 2012-05-28 14:16:31 +0400 | [diff] [blame] | 661 | if (server->ops->clear_stats) |
| 662 | server->ops->clear_stats(tcon); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 663 | } |
| 664 | } |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 665 | } |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 666 | spin_unlock(&cifs_tcp_ses_lock); |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 667 | } else { |
| 668 | return rc; |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 669 | } |
| 670 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 671 | return count; |
Steve French | 1047abc | 2005-10-11 19:58:06 -0700 | [diff] [blame] | 672 | } |
| 673 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 674 | static int cifs_stats_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 675 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 676 | int i; |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 677 | #ifdef CONFIG_CIFS_STATS2 |
| 678 | int j; |
| 679 | #endif /* STATS2 */ |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 680 | struct TCP_Server_Info *server; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 681 | struct cifs_ses *ses; |
| 682 | struct cifs_tcon *tcon; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 683 | |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 684 | seq_printf(m, "Resources in use\nCIFS Session: %d\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 685 | sesInfoAllocCount.counter); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 686 | seq_printf(m, "Share (unique mount targets): %d\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 687 | tconInfoAllocCount.counter); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 688 | seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n", |
Steve French | c2c17dd | 2022-07-15 23:45:45 -0500 | [diff] [blame] | 689 | buf_alloc_count.counter, |
Steve French | b8643e1 | 2005-04-28 22:41:07 -0700 | [diff] [blame] | 690 | cifs_min_rcv + tcpSesAllocCount.counter); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 691 | seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n", |
Steve French | c2c17dd | 2022-07-15 23:45:45 -0500 | [diff] [blame] | 692 | small_buf_alloc_count.counter, cifs_min_small); |
Steve French | 07475ff | 2005-12-03 14:11:37 -0800 | [diff] [blame] | 693 | #ifdef CONFIG_CIFS_STATS2 |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 694 | seq_printf(m, "Total Large %d Small %d Allocations\n", |
Steve French | c2c17dd | 2022-07-15 23:45:45 -0500 | [diff] [blame] | 695 | atomic_read(&total_buf_alloc_count), |
| 696 | atomic_read(&total_small_buf_alloc_count)); |
Steve French | 07475ff | 2005-12-03 14:11:37 -0800 | [diff] [blame] | 697 | #endif /* CONFIG_CIFS_STATS2 */ |
| 698 | |
Steve French | c2c17dd | 2022-07-15 23:45:45 -0500 | [diff] [blame] | 699 | seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&mid_count)); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 700 | seq_printf(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 701 | "\n%d session %d share reconnects\n", |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 702 | tcpSesReconnectCount.counter, tconInfoReconnectCount.counter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 703 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 704 | seq_printf(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 705 | "Total vfs operations: %d maximum at one time: %d\n", |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 706 | GlobalCurrentXid, GlobalMaxActiveXid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 707 | |
| 708 | i = 0; |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 709 | spin_lock(&cifs_tcp_ses_lock); |
Baokun Li | a506ccb | 2021-06-17 19:36:40 +0800 | [diff] [blame] | 710 | list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) { |
Steve French | 1b63f18 | 2019-09-09 22:57:11 -0500 | [diff] [blame] | 711 | seq_printf(m, "\nMax requests in flight: %d", server->max_in_flight); |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 712 | #ifdef CONFIG_CIFS_STATS2 |
Steve French | 433b8dd | 2019-03-26 13:53:21 -0500 | [diff] [blame] | 713 | seq_puts(m, "\nTotal time spent processing by command. Time "); |
| 714 | seq_printf(m, "units are jiffies (%d per second)\n", HZ); |
| 715 | seq_puts(m, " SMB3 CMD\tNumber\tTotal Time\tFastest\tSlowest\n"); |
| 716 | seq_puts(m, " --------\t------\t----------\t-------\t-------\n"); |
| 717 | for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++) |
| 718 | seq_printf(m, " %d\t\t%d\t%llu\t\t%u\t%u\n", j, |
| 719 | atomic_read(&server->num_cmds[j]), |
| 720 | server->time_per_cmd[j], |
| 721 | server->fastest_cmd[j], |
| 722 | server->slowest_cmd[j]); |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 723 | for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++) |
Paulo Alcantara | 90c49fc | 2023-04-21 15:52:32 -0300 | [diff] [blame] | 724 | if (atomic_read(&server->smb2slowcmd[j])) { |
| 725 | spin_lock(&server->srv_lock); |
Steve French | 433b8dd | 2019-03-26 13:53:21 -0500 | [diff] [blame] | 726 | seq_printf(m, " %d slow responses from %s for command %d\n", |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 727 | atomic_read(&server->smb2slowcmd[j]), |
| 728 | server->hostname, j); |
Paulo Alcantara | 90c49fc | 2023-04-21 15:52:32 -0300 | [diff] [blame] | 729 | spin_unlock(&server->srv_lock); |
| 730 | } |
Steve French | 468d677 | 2018-08-04 05:24:34 -0500 | [diff] [blame] | 731 | #endif /* STATS2 */ |
Enzo Matsumiya | 9543c8a | 2022-07-22 14:02:59 -0300 | [diff] [blame] | 732 | list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) { |
| 733 | list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 734 | i++; |
Steve French | 68e1456 | 2022-09-21 14:05:53 -0500 | [diff] [blame] | 735 | seq_printf(m, "\n%d) %s", i, tcon->tree_name); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 736 | if (tcon->need_reconnect) |
| 737 | seq_puts(m, "\tDISCONNECTED "); |
Pavel Shilovsky | 44c5818 | 2012-05-28 14:16:31 +0400 | [diff] [blame] | 738 | seq_printf(m, "\nSMBs: %d", |
| 739 | atomic_read(&tcon->num_smbs_sent)); |
| 740 | if (server->ops->print_stats) |
| 741 | server->ops->print_stats(m, tcon); |
Jeff Layton | f1987b4 | 2008-11-15 11:12:47 -0500 | [diff] [blame] | 742 | } |
| 743 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 744 | } |
Suresh Jayaraman | 3f9bcca | 2010-10-18 23:29:37 +0530 | [diff] [blame] | 745 | spin_unlock(&cifs_tcp_ses_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 746 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 747 | seq_putc(m, '\n'); |
| 748 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 749 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 750 | |
| 751 | static int cifs_stats_proc_open(struct inode *inode, struct file *file) |
| 752 | { |
| 753 | return single_open(file, cifs_stats_proc_show, NULL); |
| 754 | } |
| 755 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 756 | static const struct proc_ops cifs_stats_proc_ops = { |
| 757 | .proc_open = cifs_stats_proc_open, |
| 758 | .proc_read = seq_read, |
| 759 | .proc_lseek = seq_lseek, |
| 760 | .proc_release = single_release, |
| 761 | .proc_write = cifs_stats_proc_write, |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 762 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 763 | |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 764 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 765 | #define PROC_FILE_DEFINE(name) \ |
| 766 | static ssize_t name##_write(struct file *file, const char __user *buffer, \ |
| 767 | size_t count, loff_t *ppos) \ |
| 768 | { \ |
| 769 | int rc; \ |
Steve French | 43960dc | 2023-11-06 13:31:45 -0600 | [diff] [blame] | 770 | rc = kstrtoint_from_user(buffer, count, 10, &name); \ |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 771 | if (rc) \ |
| 772 | return rc; \ |
| 773 | return count; \ |
| 774 | } \ |
| 775 | static int name##_proc_show(struct seq_file *m, void *v) \ |
| 776 | { \ |
Steve French | 43960dc | 2023-11-06 13:31:45 -0600 | [diff] [blame] | 777 | seq_printf(m, "%d\n", name); \ |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 778 | return 0; \ |
| 779 | } \ |
| 780 | static int name##_open(struct inode *inode, struct file *file) \ |
| 781 | { \ |
| 782 | return single_open(file, name##_proc_show, NULL); \ |
| 783 | } \ |
| 784 | \ |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 785 | static const struct proc_ops cifs_##name##_proc_fops = { \ |
| 786 | .proc_open = name##_open, \ |
| 787 | .proc_read = seq_read, \ |
| 788 | .proc_lseek = seq_lseek, \ |
| 789 | .proc_release = single_release, \ |
| 790 | .proc_write = name##_write, \ |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 791 | } |
| 792 | |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 793 | PROC_FILE_DEFINE(rdma_readwrite_threshold); |
| 794 | PROC_FILE_DEFINE(smbd_max_frmr_depth); |
| 795 | PROC_FILE_DEFINE(smbd_keep_alive_interval); |
| 796 | PROC_FILE_DEFINE(smbd_max_receive_size); |
| 797 | PROC_FILE_DEFINE(smbd_max_fragmented_recv_size); |
| 798 | PROC_FILE_DEFINE(smbd_max_send_size); |
| 799 | PROC_FILE_DEFINE(smbd_send_credit_target); |
| 800 | PROC_FILE_DEFINE(smbd_receive_credit_max); |
| 801 | #endif |
| 802 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 803 | static struct proc_dir_entry *proc_fs_cifs; |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 804 | static const struct proc_ops cifsFYI_proc_ops; |
| 805 | static const struct proc_ops cifs_lookup_cache_proc_ops; |
| 806 | static const struct proc_ops traceSMB_proc_ops; |
| 807 | static const struct proc_ops cifs_security_flags_proc_ops; |
| 808 | static const struct proc_ops cifs_linux_ext_proc_ops; |
Aurelien Aptel | 94b0595a | 2021-03-18 13:52:59 +0100 | [diff] [blame] | 809 | static const struct proc_ops cifs_mount_params_proc_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 810 | |
| 811 | void |
| 812 | cifs_proc_init(void) |
| 813 | { |
Alexey Dobriyan | 36a5aeb | 2008-04-29 01:01:42 -0700 | [diff] [blame] | 814 | proc_fs_cifs = proc_mkdir("fs/cifs", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 815 | if (proc_fs_cifs == NULL) |
| 816 | return; |
| 817 | |
Christoph Hellwig | 3f3942a | 2018-05-15 15:57:23 +0200 | [diff] [blame] | 818 | proc_create_single("DebugData", 0, proc_fs_cifs, |
| 819 | cifs_debug_data_proc_show); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 820 | |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 821 | proc_create_single("open_files", 0400, proc_fs_cifs, |
| 822 | cifs_debug_files_proc_show); |
| 823 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 824 | proc_create("Stats", 0644, proc_fs_cifs, &cifs_stats_proc_ops); |
| 825 | proc_create("cifsFYI", 0644, proc_fs_cifs, &cifsFYI_proc_ops); |
| 826 | proc_create("traceSMB", 0644, proc_fs_cifs, &traceSMB_proc_ops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 827 | proc_create("LinuxExtensionsEnabled", 0644, proc_fs_cifs, |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 828 | &cifs_linux_ext_proc_ops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 829 | proc_create("SecurityFlags", 0644, proc_fs_cifs, |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 830 | &cifs_security_flags_proc_ops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 831 | proc_create("LookupCacheEnabled", 0644, proc_fs_cifs, |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 832 | &cifs_lookup_cache_proc_ops); |
Paulo Alcantara | 54be1f6 | 2018-11-14 16:01:21 -0200 | [diff] [blame] | 833 | |
Aurelien Aptel | 94b0595a | 2021-03-18 13:52:59 +0100 | [diff] [blame] | 834 | proc_create("mount_params", 0444, proc_fs_cifs, &cifs_mount_params_proc_ops); |
| 835 | |
Paulo Alcantara | 54be1f6 | 2018-11-14 16:01:21 -0200 | [diff] [blame] | 836 | #ifdef CONFIG_CIFS_DFS_UPCALL |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 837 | proc_create("dfscache", 0644, proc_fs_cifs, &dfscache_proc_ops); |
Paulo Alcantara | 54be1f6 | 2018-11-14 16:01:21 -0200 | [diff] [blame] | 838 | #endif |
| 839 | |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 840 | #ifdef CONFIG_CIFS_SMB_DIRECT |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 841 | proc_create("rdma_readwrite_threshold", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 842 | &cifs_rdma_readwrite_threshold_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 843 | proc_create("smbd_max_frmr_depth", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 844 | &cifs_smbd_max_frmr_depth_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 845 | proc_create("smbd_keep_alive_interval", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 846 | &cifs_smbd_keep_alive_interval_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 847 | proc_create("smbd_max_receive_size", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 848 | &cifs_smbd_max_receive_size_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 849 | proc_create("smbd_max_fragmented_recv_size", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 850 | &cifs_smbd_max_fragmented_recv_size_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 851 | proc_create("smbd_max_send_size", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 852 | &cifs_smbd_max_send_size_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 853 | proc_create("smbd_send_credit_target", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 854 | &cifs_smbd_send_credit_target_proc_fops); |
Ronnie Sahlberg | 6539e7f | 2018-05-24 14:18:05 +1000 | [diff] [blame] | 855 | proc_create("smbd_receive_credit_max", 0644, proc_fs_cifs, |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 856 | &cifs_smbd_receive_credit_max_proc_fops); |
| 857 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 858 | } |
| 859 | |
| 860 | void |
| 861 | cifs_proc_clean(void) |
| 862 | { |
| 863 | if (proc_fs_cifs == NULL) |
| 864 | return; |
| 865 | |
| 866 | remove_proc_entry("DebugData", proc_fs_cifs); |
Steve French | dfe33f9 | 2018-10-30 19:50:31 -0500 | [diff] [blame] | 867 | remove_proc_entry("open_files", proc_fs_cifs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 868 | remove_proc_entry("cifsFYI", proc_fs_cifs); |
| 869 | remove_proc_entry("traceSMB", proc_fs_cifs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 870 | remove_proc_entry("Stats", proc_fs_cifs); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 871 | remove_proc_entry("SecurityFlags", proc_fs_cifs); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 872 | remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 873 | remove_proc_entry("LookupCacheEnabled", proc_fs_cifs); |
Aurelien Aptel | 94b0595a | 2021-03-18 13:52:59 +0100 | [diff] [blame] | 874 | remove_proc_entry("mount_params", proc_fs_cifs); |
Paulo Alcantara | 54be1f6 | 2018-11-14 16:01:21 -0200 | [diff] [blame] | 875 | |
| 876 | #ifdef CONFIG_CIFS_DFS_UPCALL |
| 877 | remove_proc_entry("dfscache", proc_fs_cifs); |
| 878 | #endif |
Long Li | d8ec913 | 2017-11-07 01:54:58 -0700 | [diff] [blame] | 879 | #ifdef CONFIG_CIFS_SMB_DIRECT |
| 880 | remove_proc_entry("rdma_readwrite_threshold", proc_fs_cifs); |
| 881 | remove_proc_entry("smbd_max_frmr_depth", proc_fs_cifs); |
| 882 | remove_proc_entry("smbd_keep_alive_interval", proc_fs_cifs); |
| 883 | remove_proc_entry("smbd_max_receive_size", proc_fs_cifs); |
| 884 | remove_proc_entry("smbd_max_fragmented_recv_size", proc_fs_cifs); |
| 885 | remove_proc_entry("smbd_max_send_size", proc_fs_cifs); |
| 886 | remove_proc_entry("smbd_send_credit_target", proc_fs_cifs); |
| 887 | remove_proc_entry("smbd_receive_credit_max", proc_fs_cifs); |
| 888 | #endif |
Alexey Dobriyan | 36a5aeb | 2008-04-29 01:01:42 -0700 | [diff] [blame] | 889 | remove_proc_entry("fs/cifs", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 890 | } |
| 891 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 892 | static int cifsFYI_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 893 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 894 | seq_printf(m, "%d\n", cifsFYI); |
| 895 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 896 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 897 | |
| 898 | static int cifsFYI_proc_open(struct inode *inode, struct file *file) |
| 899 | { |
| 900 | return single_open(file, cifsFYI_proc_show, NULL); |
| 901 | } |
| 902 | |
| 903 | static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer, |
| 904 | size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 905 | { |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 906 | char c[2] = { '\0' }; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 907 | bool bv; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 908 | int rc; |
| 909 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 910 | rc = get_user(c[0], buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 911 | if (rc) |
| 912 | return rc; |
Christophe JAILLET | 9f5d1a8 | 2023-01-14 09:58:15 +0100 | [diff] [blame] | 913 | if (kstrtobool(c, &bv) == 0) |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 914 | cifsFYI = bv; |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 915 | else if ((c[0] > '1') && (c[0] <= '9')) |
| 916 | cifsFYI = (int) (c[0] - '0'); /* see cifs_debug.h for meanings */ |
Ronnie Sahlberg | 25ad1cb | 2018-05-24 09:53:39 +1000 | [diff] [blame] | 917 | else |
| 918 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 919 | |
| 920 | return count; |
| 921 | } |
| 922 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 923 | static const struct proc_ops cifsFYI_proc_ops = { |
| 924 | .proc_open = cifsFYI_proc_open, |
| 925 | .proc_read = seq_read, |
| 926 | .proc_lseek = seq_lseek, |
| 927 | .proc_release = single_release, |
| 928 | .proc_write = cifsFYI_proc_write, |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 929 | }; |
| 930 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 931 | 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] | 932 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 933 | seq_printf(m, "%d\n", linuxExtEnabled); |
| 934 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 935 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 936 | |
| 937 | static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file) |
| 938 | { |
| 939 | return single_open(file, cifs_linux_ext_proc_show, NULL); |
| 940 | } |
| 941 | |
| 942 | static ssize_t cifs_linux_ext_proc_write(struct file *file, |
| 943 | const char __user *buffer, size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 944 | { |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 945 | int rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 946 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 947 | rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled); |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 948 | if (rc) |
| 949 | return rc; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 950 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 951 | return count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 952 | } |
| 953 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 954 | static const struct proc_ops cifs_linux_ext_proc_ops = { |
| 955 | .proc_open = cifs_linux_ext_proc_open, |
| 956 | .proc_read = seq_read, |
| 957 | .proc_lseek = seq_lseek, |
| 958 | .proc_release = single_release, |
| 959 | .proc_write = cifs_linux_ext_proc_write, |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 960 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 961 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 962 | 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] | 963 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 964 | seq_printf(m, "%d\n", lookupCacheEnabled); |
| 965 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 966 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 967 | |
| 968 | static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file) |
| 969 | { |
| 970 | return single_open(file, cifs_lookup_cache_proc_show, NULL); |
| 971 | } |
| 972 | |
| 973 | static ssize_t cifs_lookup_cache_proc_write(struct file *file, |
| 974 | const char __user *buffer, size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 975 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 976 | int rc; |
| 977 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 978 | rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 979 | if (rc) |
| 980 | return rc; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 981 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 982 | return count; |
| 983 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 984 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 985 | static const struct proc_ops cifs_lookup_cache_proc_ops = { |
| 986 | .proc_open = cifs_lookup_cache_proc_open, |
| 987 | .proc_read = seq_read, |
| 988 | .proc_lseek = seq_lseek, |
| 989 | .proc_release = single_release, |
| 990 | .proc_write = cifs_lookup_cache_proc_write, |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 991 | }; |
| 992 | |
| 993 | static int traceSMB_proc_show(struct seq_file *m, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 994 | { |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 995 | seq_printf(m, "%d\n", traceSMB); |
| 996 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 997 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 998 | |
| 999 | static int traceSMB_proc_open(struct inode *inode, struct file *file) |
| 1000 | { |
| 1001 | return single_open(file, traceSMB_proc_show, NULL); |
| 1002 | } |
| 1003 | |
| 1004 | static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer, |
| 1005 | size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1006 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1007 | int rc; |
| 1008 | |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 1009 | rc = kstrtobool_from_user(buffer, count, &traceSMB); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1010 | if (rc) |
| 1011 | return rc; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 1012 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1013 | return count; |
| 1014 | } |
| 1015 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 1016 | static const struct proc_ops traceSMB_proc_ops = { |
| 1017 | .proc_open = traceSMB_proc_open, |
| 1018 | .proc_read = seq_read, |
| 1019 | .proc_lseek = seq_lseek, |
| 1020 | .proc_release = single_release, |
| 1021 | .proc_write = traceSMB_proc_write, |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1022 | }; |
| 1023 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1024 | 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] | 1025 | { |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 1026 | seq_printf(m, "0x%x\n", global_secflags); |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1027 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1028 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1029 | |
| 1030 | static int cifs_security_flags_proc_open(struct inode *inode, struct file *file) |
| 1031 | { |
| 1032 | return single_open(file, cifs_security_flags_proc_show, NULL); |
| 1033 | } |
| 1034 | |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 1035 | /* |
| 1036 | * Ensure that if someone sets a MUST flag, that we disable all other MAY |
| 1037 | * flags except for the ones corresponding to the given MUST flag. If there are |
| 1038 | * multiple MUST flags, then try to prefer more secure ones. |
| 1039 | */ |
| 1040 | static void |
| 1041 | cifs_security_flags_handle_must_flags(unsigned int *flags) |
| 1042 | { |
| 1043 | unsigned int signflags = *flags & CIFSSEC_MUST_SIGN; |
| 1044 | |
| 1045 | if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5) |
| 1046 | *flags = CIFSSEC_MUST_KRB5; |
| 1047 | else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP) |
| 1048 | *flags = CIFSSEC_MUST_NTLMSSP; |
| 1049 | else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2) |
| 1050 | *flags = CIFSSEC_MUST_NTLMV2; |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 1051 | |
| 1052 | *flags |= signflags; |
| 1053 | } |
| 1054 | |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1055 | static ssize_t cifs_security_flags_proc_write(struct file *file, |
| 1056 | const char __user *buffer, size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1057 | { |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 1058 | int rc; |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1059 | unsigned int flags; |
| 1060 | char flags_string[12]; |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 1061 | bool bv; |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1062 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 1063 | if ((count < 1) || (count > 11)) |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 1064 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1065 | |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1066 | memset(flags_string, 0, 12); |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 1067 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 1068 | if (copy_from_user(flags_string, buffer, count)) |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1069 | return -EFAULT; |
Steve French | 3979877 | 2006-05-31 22:40:51 +0000 | [diff] [blame] | 1070 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 1071 | if (count < 3) { |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1072 | /* single char or single char followed by null */ |
Christophe JAILLET | 9f5d1a8 | 2023-01-14 09:58:15 +0100 | [diff] [blame] | 1073 | if (kstrtobool(flags_string, &bv) == 0) { |
Andy Shevchenko | 28e2aed | 2014-08-27 16:49:42 +0300 | [diff] [blame] | 1074 | global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF; |
Steve French | a013689 | 2007-10-04 20:05:09 +0000 | [diff] [blame] | 1075 | return count; |
Kees Cook | 1404297 | 2016-03-17 14:22:54 -0700 | [diff] [blame] | 1076 | } else if (!isdigit(flags_string[0])) { |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 1077 | cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", |
| 1078 | flags_string); |
Steve French | a013689 | 2007-10-04 20:05:09 +0000 | [diff] [blame] | 1079 | return -EINVAL; |
| 1080 | } |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1081 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1082 | |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 1083 | /* else we have a number */ |
| 1084 | rc = kstrtouint(flags_string, 0, &flags); |
| 1085 | if (rc) { |
| 1086 | cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", |
| 1087 | flags_string); |
| 1088 | return rc; |
| 1089 | } |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1090 | |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 1091 | cifs_dbg(FYI, "sec flags 0x%x\n", flags); |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1092 | |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 1093 | if (flags == 0) { |
| 1094 | cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string); |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1095 | return -EINVAL; |
| 1096 | } |
| 1097 | |
Steve French | 221601c | 2007-06-05 20:35:06 +0000 | [diff] [blame] | 1098 | if (flags & ~CIFSSEC_MASK) { |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 1099 | cifs_dbg(VFS, "Unsupported security flags: 0x%x\n", |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 1100 | flags & ~CIFSSEC_MASK); |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1101 | return -EINVAL; |
| 1102 | } |
Jeff Layton | 7715dad | 2013-05-26 07:01:01 -0400 | [diff] [blame] | 1103 | |
Jeff Layton | 52dfb44 | 2013-05-26 07:01:02 -0400 | [diff] [blame] | 1104 | cifs_security_flags_handle_must_flags(&flags); |
| 1105 | |
Steve French | bdc4bf6e | 2006-06-02 22:57:13 +0000 | [diff] [blame] | 1106 | /* flags look ok - update the global security flags for cifs module */ |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 1107 | global_secflags = flags; |
| 1108 | if (global_secflags & CIFSSEC_MUST_SIGN) { |
Steve French | 762e5ab | 2007-06-28 18:41:42 +0000 | [diff] [blame] | 1109 | /* requiring signing implies signing is allowed */ |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 1110 | global_secflags |= CIFSSEC_MAY_SIGN; |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 1111 | cifs_dbg(FYI, "packet signing now required\n"); |
Jeff Layton | 04912d6 | 2010-04-24 07:57:45 -0400 | [diff] [blame] | 1112 | } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 1113 | cifs_dbg(FYI, "packet signing disabled\n"); |
Steve French | 762e5ab | 2007-06-28 18:41:42 +0000 | [diff] [blame] | 1114 | } |
| 1115 | /* BB should we turn on MAY flags for other MUST options? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1116 | return count; |
| 1117 | } |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1118 | |
Alexey Dobriyan | 97a3253 | 2020-02-03 17:37:17 -0800 | [diff] [blame] | 1119 | static const struct proc_ops cifs_security_flags_proc_ops = { |
| 1120 | .proc_open = cifs_security_flags_proc_open, |
| 1121 | .proc_read = seq_read, |
| 1122 | .proc_lseek = seq_lseek, |
| 1123 | .proc_release = single_release, |
| 1124 | .proc_write = cifs_security_flags_proc_write, |
Alexey Dobriyan | f984c7b | 2008-07-24 02:34:24 +0000 | [diff] [blame] | 1125 | }; |
Aurelien Aptel | 94b0595a | 2021-03-18 13:52:59 +0100 | [diff] [blame] | 1126 | |
| 1127 | /* To make it easier to debug, can help to show mount params */ |
| 1128 | static int cifs_mount_params_proc_show(struct seq_file *m, void *v) |
| 1129 | { |
| 1130 | const struct fs_parameter_spec *p; |
| 1131 | const char *type; |
| 1132 | |
| 1133 | for (p = smb3_fs_parameters; p->name; p++) { |
| 1134 | /* cannot use switch with pointers... */ |
| 1135 | if (!p->type) { |
| 1136 | if (p->flags == fs_param_neg_with_no) |
| 1137 | type = "noflag"; |
| 1138 | else |
| 1139 | type = "flag"; |
| 1140 | } else if (p->type == fs_param_is_bool) |
| 1141 | type = "bool"; |
| 1142 | else if (p->type == fs_param_is_u32) |
| 1143 | type = "u32"; |
| 1144 | else if (p->type == fs_param_is_u64) |
| 1145 | type = "u64"; |
| 1146 | else if (p->type == fs_param_is_string) |
| 1147 | type = "string"; |
| 1148 | else |
| 1149 | type = "unknown"; |
| 1150 | |
| 1151 | seq_printf(m, "%s:%s\n", p->name, type); |
| 1152 | } |
| 1153 | |
| 1154 | return 0; |
| 1155 | } |
| 1156 | |
| 1157 | static int cifs_mount_params_proc_open(struct inode *inode, struct file *file) |
| 1158 | { |
| 1159 | return single_open(file, cifs_mount_params_proc_show, NULL); |
| 1160 | } |
| 1161 | |
| 1162 | static const struct proc_ops cifs_mount_params_proc_ops = { |
| 1163 | .proc_open = cifs_mount_params_proc_open, |
| 1164 | .proc_read = seq_read, |
| 1165 | .proc_lseek = seq_lseek, |
| 1166 | .proc_release = single_release, |
| 1167 | /* No need for write for now */ |
| 1168 | /* .proc_write = cifs_mount_params_proc_write, */ |
| 1169 | }; |
| 1170 | |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 1171 | #else |
Steve French | e086fce | 2008-02-18 04:03:58 +0000 | [diff] [blame] | 1172 | inline void cifs_proc_init(void) |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 1173 | { |
| 1174 | } |
| 1175 | |
Steve French | e086fce | 2008-02-18 04:03:58 +0000 | [diff] [blame] | 1176 | inline void cifs_proc_clean(void) |
Steve French | 90c81e0 | 2008-02-12 20:32:36 +0000 | [diff] [blame] | 1177 | { |
| 1178 | } |
| 1179 | #endif /* PROC_FS */ |