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