~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/cifs_debug.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  *   fs/cifs_debug.c
  4  *
  5  *   Copyright (C) International Business Machines  Corp., 2000,2005
  6  *
  7  *   Modified by Steve French (sfrench@us.ibm.com)
  8  */
  9 #include <linux/fs.h>
 10 #include <linux/string.h>
 11 #include <linux/ctype.h>
 12 #include <linux/module.h>
 13 #include <linux/proc_fs.h>
 14 #include <linux/uaccess.h>
 15 #include "cifspdu.h"
 16 #include "cifsglob.h"
 17 #include "cifsproto.h"
 18 #include "cifs_debug.h"
 19 #include "cifsfs.h"
 20 #ifdef CONFIG_CIFS_DFS_UPCALL
 21 #include "dfs_cache.h"
 22 #endif
 23 #ifdef CONFIG_CIFS_SMB_DIRECT
 24 #include "smbdirect.h"
 25 #endif
 26 
 27 void
 28 cifs_dump_mem(char *label, void *data, int length)
 29 {
 30         pr_debug("%s: dump of %d bytes of data at 0x%p\n", label, length, data);
 31         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 4,
 32                        data, length, true);
 33 }
 34 
 35 void cifs_dump_detail(void *buf, struct TCP_Server_Info *server)
 36 {
 37 #ifdef CONFIG_CIFS_DEBUG2
 38         struct smb_hdr *smb = (struct smb_hdr *)buf;
 39 
 40         cifs_dbg(VFS, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d\n",
 41                  smb->Command, smb->Status.CifsError,
 42                  smb->Flags, smb->Flags2, smb->Mid, smb->Pid);
 43         cifs_dbg(VFS, "smb buf %p len %u\n", smb,
 44                  server->ops->calc_smb_size(smb, server));
 45 #endif /* CONFIG_CIFS_DEBUG2 */
 46 }
 47 
 48 void cifs_dump_mids(struct TCP_Server_Info *server)
 49 {
 50 #ifdef CONFIG_CIFS_DEBUG2
 51         struct list_head *tmp;
 52         struct mid_q_entry *mid_entry;
 53 
 54         if (server == NULL)
 55                 return;
 56 
 57         cifs_dbg(VFS, "Dump pending requests:\n");
 58         spin_lock(&GlobalMid_Lock);
 59         list_for_each(tmp, &server->pending_mid_q) {
 60                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 61                 cifs_dbg(VFS, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu\n",
 62                          mid_entry->mid_state,
 63                          le16_to_cpu(mid_entry->command),
 64                          mid_entry->pid,
 65                          mid_entry->callback_data,
 66                          mid_entry->mid);
 67 #ifdef CONFIG_CIFS_STATS2
 68                 cifs_dbg(VFS, "IsLarge: %d buf: %p time rcv: %ld now: %ld\n",
 69                          mid_entry->large_buf,
 70                          mid_entry->resp_buf,
 71                          mid_entry->when_received,
 72                          jiffies);
 73 #endif /* STATS2 */
 74                 cifs_dbg(VFS, "IsMult: %d IsEnd: %d\n",
 75                          mid_entry->multiRsp, mid_entry->multiEnd);
 76                 if (mid_entry->resp_buf) {
 77                         cifs_dump_detail(mid_entry->resp_buf, server);
 78                         cifs_dump_mem("existing buf: ",
 79                                 mid_entry->resp_buf, 62);
 80                 }
 81         }
 82         spin_unlock(&GlobalMid_Lock);
 83 #endif /* CONFIG_CIFS_DEBUG2 */
 84 }
 85 
 86 #ifdef CONFIG_PROC_FS
 87 static void cifs_debug_tcon(struct seq_file *m, struct cifs_tcon *tcon)
 88 {
 89         __u32 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
 90 
 91         seq_printf(m, "%s Mounts: %d ", tcon->treeName, tcon->tc_count);
 92         if (tcon->nativeFileSystem)
 93                 seq_printf(m, "Type: %s ", tcon->nativeFileSystem);
 94         seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x\n\tPathComponentMax: %d Status: %d",
 95                    le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
 96                    le32_to_cpu(tcon->fsAttrInfo.Attributes),
 97                    le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
 98                    tcon->tidStatus);
 99         if (dev_type == FILE_DEVICE_DISK)
100                 seq_puts(m, " type: DISK ");
101         else if (dev_type == FILE_DEVICE_CD_ROM)
102                 seq_puts(m, " type: CDROM ");
103         else
104                 seq_printf(m, " type: %d ", dev_type);
105 
106         seq_printf(m, "Serial Number: 0x%x", tcon->vol_serial_number);
107 
108         if ((tcon->seal) ||
109             (tcon->ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) ||
110             (tcon->share_flags & SHI1005_FLAGS_ENCRYPT_DATA))
111                 seq_printf(m, " Encrypted");
112         if (tcon->nocase)
113                 seq_printf(m, " nocase");
114         if (tcon->unix_ext)
115                 seq_printf(m, " POSIX Extensions");
116         if (tcon->ses->server->ops->dump_share_caps)
117                 tcon->ses->server->ops->dump_share_caps(m, tcon);
118 
119         if (tcon->need_reconnect)
120                 seq_puts(m, "\tDISCONNECTED ");
121         seq_putc(m, '\n');
122 }
123 
124 static void
125 cifs_dump_channel(struct seq_file *m, int i, struct cifs_chan *chan)
126 {
127         struct TCP_Server_Info *server = chan->server;
128 
129         seq_printf(m, "\t\tChannel %d Number of credits: %d Dialect 0x%x "
130                    "TCP status: %d Instance: %d Local Users To Server: %d "
131                    "SecMode: 0x%x Req On Wire: %d In Send: %d "
132                    "In MaxReq Wait: %d\n",
133                    i+1,
134                    server->credits,
135                    server->dialect,
136                    server->tcpStatus,
137                    server->reconnect_instance,
138                    server->srv_count,
139                    server->sec_mode,
140                    in_flight(server),
141                    atomic_read(&server->in_send),
142                    atomic_read(&server->num_waiters));
143 }
144 
145 static void
146 cifs_dump_iface(struct seq_file *m, struct cifs_server_iface *iface)
147 {
148         struct sockaddr_in *ipv4 = (struct sockaddr_in *)&iface->sockaddr;
149         struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&iface->sockaddr;
150 
151         seq_printf(m, "\tSpeed: %zu bps\n", iface->speed);
152         seq_puts(m, "\t\tCapabilities: ");
153         if (iface->rdma_capable)
154                 seq_puts(m, "rdma ");
155         if (iface->rss_capable)
156                 seq_puts(m, "rss ");
157         seq_putc(m, '\n');
158         if (iface->sockaddr.ss_family == AF_INET)
159                 seq_printf(m, "\t\tIPv4: %pI4\n", &ipv4->sin_addr);
160         else if (iface->sockaddr.ss_family == AF_INET6)
161                 seq_printf(m, "\t\tIPv6: %pI6\n", &ipv6->sin6_addr);
162 }
163 
164 static int cifs_debug_files_proc_show(struct seq_file *m, void *v)
165 {
166         struct list_head *stmp, *tmp, *tmp1, *tmp2;
167         struct TCP_Server_Info *server;
168         struct cifs_ses *ses;
169         struct cifs_tcon *tcon;
170         struct cifsFileInfo *cfile;
171 
172         seq_puts(m, "# Version:1\n");
173         seq_puts(m, "# Format:\n");
174         seq_puts(m, "# <tree id> <persistent fid> <flags> <count> <pid> <uid>");
175 #ifdef CONFIG_CIFS_DEBUG2
176         seq_printf(m, " <filename> <mid>\n");
177 #else
178         seq_printf(m, " <filename>\n");
179 #endif /* CIFS_DEBUG2 */
180         spin_lock(&cifs_tcp_ses_lock);
181         list_for_each(stmp, &cifs_tcp_ses_list) {
182                 server = list_entry(stmp, struct TCP_Server_Info,
183                                     tcp_ses_list);
184                 list_for_each(tmp, &server->smb_ses_list) {
185                         ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
186                         list_for_each(tmp1, &ses->tcon_list) {
187                                 tcon = list_entry(tmp1, struct cifs_tcon, tcon_list);
188                                 spin_lock(&tcon->open_file_lock);
189                                 list_for_each(tmp2, &tcon->openFileList) {
190                                         cfile = list_entry(tmp2, struct cifsFileInfo,
191                                                      tlist);
192                                         seq_printf(m,
193                                                 "0x%x 0x%llx 0x%x %d %d %d %s",
194                                                 tcon->tid,
195                                                 cfile->fid.persistent_fid,
196                                                 cfile->f_flags,
197                                                 cfile->count,
198                                                 cfile->pid,
199                                                 from_kuid(&init_user_ns, cfile->uid),
200                                                 cfile->dentry->d_name.name);
201 #ifdef CONFIG_CIFS_DEBUG2
202                                         seq_printf(m, " 0x%llx\n", cfile->fid.mid);
203 #else
204                                         seq_printf(m, "\n");
205 #endif /* CIFS_DEBUG2 */
206                                 }
207                                 spin_unlock(&tcon->open_file_lock);
208                         }
209                 }
210         }
211         spin_unlock(&cifs_tcp_ses_lock);
212         seq_putc(m, '\n');
213         return 0;
214 }
215 
216 static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
217 {
218         struct list_head *tmp1, *tmp2, *tmp3;
219         struct mid_q_entry *mid_entry;
220         struct TCP_Server_Info *server;
221         struct cifs_ses *ses;
222         struct cifs_tcon *tcon;
223         int i, j;
224 
225         seq_puts(m,
226                     "Display Internal CIFS Data Structures for Debugging\n"
227                     "---------------------------------------------------\n");
228         seq_printf(m, "CIFS Version %s\n", CIFS_VERSION);
229         seq_printf(m, "Features:");
230 #ifdef CONFIG_CIFS_DFS_UPCALL
231         seq_printf(m, " DFS");
232 #endif
233 #ifdef CONFIG_CIFS_FSCACHE
234         seq_printf(m, ",FSCACHE");
235 #endif
236 #ifdef CONFIG_CIFS_SMB_DIRECT
237         seq_printf(m, ",SMB_DIRECT");
238 #endif
239 #ifdef CONFIG_CIFS_STATS2
240         seq_printf(m, ",STATS2");
241 #else
242         seq_printf(m, ",STATS");
243 #endif
244 #ifdef CONFIG_CIFS_DEBUG2
245         seq_printf(m, ",DEBUG2");
246 #elif defined(CONFIG_CIFS_DEBUG)
247         seq_printf(m, ",DEBUG");
248 #endif
249 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
250         seq_printf(m, ",ALLOW_INSECURE_LEGACY");
251 #endif
252 #ifdef CONFIG_CIFS_WEAK_PW_HASH
253         seq_printf(m, ",WEAK_PW_HASH");
254 #endif
255 #ifdef CONFIG_CIFS_POSIX
256         seq_printf(m, ",CIFS_POSIX");
257 #endif
258 #ifdef CONFIG_CIFS_UPCALL
259         seq_printf(m, ",UPCALL(SPNEGO)");
260 #endif
261 #ifdef CONFIG_CIFS_XATTR
262         seq_printf(m, ",XATTR");
263 #endif
264         seq_printf(m, ",ACL");
265         seq_putc(m, '\n');
266         seq_printf(m, "CIFSMaxBufSize: %d\n", CIFSMaxBufSize);
267         seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid);
268         seq_printf(m, "Servers:");
269 
270         i = 0;
271         spin_lock(&cifs_tcp_ses_lock);
272         list_for_each(tmp1, &cifs_tcp_ses_list) {
273                 server = list_entry(tmp1, struct TCP_Server_Info,
274                                     tcp_ses_list);
275 
276 #ifdef CONFIG_CIFS_SMB_DIRECT
277                 if (!server->rdma)
278                         goto skip_rdma;
279 
280                 if (!server->smbd_conn) {
281                         seq_printf(m, "\nSMBDirect transport not available");
282                         goto skip_rdma;
283                 }
284 
285                 seq_printf(m, "\nSMBDirect (in hex) protocol version: %x "
286                         "transport status: %x",
287                         server->smbd_conn->protocol,
288                         server->smbd_conn->transport_status);
289                 seq_printf(m, "\nConn receive_credit_max: %x "
290                         "send_credit_target: %x max_send_size: %x",
291                         server->smbd_conn->receive_credit_max,
292                         server->smbd_conn->send_credit_target,
293                         server->smbd_conn->max_send_size);
294                 seq_printf(m, "\nConn max_fragmented_recv_size: %x "
295                         "max_fragmented_send_size: %x max_receive_size:%x",
296                         server->smbd_conn->max_fragmented_recv_size,
297                         server->smbd_conn->max_fragmented_send_size,
298                         server->smbd_conn->max_receive_size);
299                 seq_printf(m, "\nConn keep_alive_interval: %x "
300                         "max_readwrite_size: %x rdma_readwrite_threshold: %x",
301                         server->smbd_conn->keep_alive_interval,
302                         server->smbd_conn->max_readwrite_size,
303                         server->smbd_conn->rdma_readwrite_threshold);
304                 seq_printf(m, "\nDebug count_get_receive_buffer: %x "
305                         "count_put_receive_buffer: %x count_send_empty: %x",
306                         server->smbd_conn->count_get_receive_buffer,
307                         server->smbd_conn->count_put_receive_buffer,
308                         server->smbd_conn->count_send_empty);
309                 seq_printf(m, "\nRead Queue count_reassembly_queue: %x "
310                         "count_enqueue_reassembly_queue: %x "
311                         "count_dequeue_reassembly_queue: %x "
312                         "fragment_reassembly_remaining: %x "
313                         "reassembly_data_length: %x "
314                         "reassembly_queue_length: %x",
315                         server->smbd_conn->count_reassembly_queue,
316                         server->smbd_conn->count_enqueue_reassembly_queue,
317                         server->smbd_conn->count_dequeue_reassembly_queue,
318                         server->smbd_conn->fragment_reassembly_remaining,
319                         server->smbd_conn->reassembly_data_length,
320                         server->smbd_conn->reassembly_queue_length);
321                 seq_printf(m, "\nCurrent Credits send_credits: %x "
322                         "receive_credits: %x receive_credit_target: %x",
323                         atomic_read(&server->smbd_conn->send_credits),
324                         atomic_read(&server->smbd_conn->receive_credits),
325                         server->smbd_conn->receive_credit_target);
326                 seq_printf(m, "\nPending send_pending: %x ",
327                         atomic_read(&server->smbd_conn->send_pending));
328                 seq_printf(m, "\nReceive buffers count_receive_queue: %x "
329                         "count_empty_packet_queue: %x",
330                         server->smbd_conn->count_receive_queue,
331                         server->smbd_conn->count_empty_packet_queue);
332                 seq_printf(m, "\nMR responder_resources: %x "
333                         "max_frmr_depth: %x mr_type: %x",
334                         server->smbd_conn->responder_resources,
335                         server->smbd_conn->max_frmr_depth,
336                         server->smbd_conn->mr_type);
337                 seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
338                         atomic_read(&server->smbd_conn->mr_ready_count),
339                         atomic_read(&server->smbd_conn->mr_used_count));
340 skip_rdma:
341 #endif
342                 seq_printf(m, "\nNumber of credits: %d Dialect 0x%x",
343                         server->credits,  server->dialect);
344                 if (server->compress_algorithm == SMB3_COMPRESS_LZNT1)
345                         seq_printf(m, " COMPRESS_LZNT1");
346                 else if (server->compress_algorithm == SMB3_COMPRESS_LZ77)
347                         seq_printf(m, " COMPRESS_LZ77");
348                 else if (server->compress_algorithm == SMB3_COMPRESS_LZ77_HUFF)
349                         seq_printf(m, " COMPRESS_LZ77_HUFF");
350                 if (server->sign)
351                         seq_printf(m, " signed");
352                 if (server->posix_ext_supported)
353                         seq_printf(m, " posix");
354 
355                 i++;
356                 list_for_each(tmp2, &server->smb_ses_list) {
357                         ses = list_entry(tmp2, struct cifs_ses,
358                                          smb_ses_list);
359                         if ((ses->serverDomain == NULL) ||
360                                 (ses->serverOS == NULL) ||
361                                 (ses->serverNOS == NULL)) {
362                                 seq_printf(m, "\n%d) Name: %s Uses: %d Capability: 0x%x\tSession Status: %d ",
363                                         i, ses->serverName, ses->ses_count,
364                                         ses->capabilities, ses->status);
365                                 if (ses->session_flags & SMB2_SESSION_FLAG_IS_GUEST)
366                                         seq_printf(m, "Guest\t");
367                                 else if (ses->session_flags & SMB2_SESSION_FLAG_IS_NULL)
368                                         seq_printf(m, "Anonymous\t");
369                         } else {
370                                 seq_printf(m,
371                                     "\n%d) Name: %s  Domain: %s Uses: %d OS:"
372                                     " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB"
373                                     " session status: %d ",
374                                 i, ses->serverName, ses->serverDomain,
375                                 ses->ses_count, ses->serverOS, ses->serverNOS,
376                                 ses->capabilities, ses->status);
377                         }
378                         if (server->rdma)
379                                 seq_printf(m, "RDMA\n\t");
380                         seq_printf(m, "TCP status: %d Instance: %d\n\tLocal Users To "
381                                    "Server: %d SecMode: 0x%x Req On Wire: %d",
382                                    server->tcpStatus,
383                                    server->reconnect_instance,
384                                    server->srv_count,
385                                    server->sec_mode, in_flight(server));
386 
387                         seq_printf(m, " In Send: %d In MaxReq Wait: %d",
388                                 atomic_read(&server->in_send),
389                                 atomic_read(&server->num_waiters));
390 
391                         /* dump session id helpful for use with network trace */
392                         seq_printf(m, " SessionId: 0x%llx", ses->Suid);
393                         if (ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA)
394                                 seq_puts(m, " encrypted");
395                         if (ses->sign)
396                                 seq_puts(m, " signed");
397 
398                         if (ses->chan_count > 1) {
399                                 seq_printf(m, "\n\n\tExtra Channels: %zu\n",
400                                            ses->chan_count-1);
401                                 for (j = 1; j < ses->chan_count; j++)
402                                         cifs_dump_channel(m, j, &ses->chans[j]);
403                         }
404 
405                         seq_puts(m, "\n\tShares:");
406                         j = 0;
407 
408                         seq_printf(m, "\n\t%d) IPC: ", j);
409                         if (ses->tcon_ipc)
410                                 cifs_debug_tcon(m, ses->tcon_ipc);
411                         else
412                                 seq_puts(m, "none\n");
413 
414                         list_for_each(tmp3, &ses->tcon_list) {
415                                 tcon = list_entry(tmp3, struct cifs_tcon,
416                                                   tcon_list);
417                                 ++j;
418                                 seq_printf(m, "\n\t%d) ", j);
419                                 cifs_debug_tcon(m, tcon);
420                         }
421 
422                         seq_puts(m, "\n\tMIDs:\n");
423 
424                         spin_lock(&GlobalMid_Lock);
425                         list_for_each(tmp3, &server->pending_mid_q) {
426                                 mid_entry = list_entry(tmp3, struct mid_q_entry,
427                                         qhead);
428                                 seq_printf(m, "\tState: %d com: %d pid:"
429                                               " %d cbdata: %p mid %llu\n",
430                                               mid_entry->mid_state,
431                                               le16_to_cpu(mid_entry->command),
432                                               mid_entry->pid,
433                                               mid_entry->callback_data,
434                                               mid_entry->mid);
435                         }
436                         spin_unlock(&GlobalMid_Lock);
437 
438                         spin_lock(&ses->iface_lock);
439                         if (ses->iface_count)
440                                 seq_printf(m, "\n\tServer interfaces: %zu\n",
441                                            ses->iface_count);
442                         for (j = 0; j < ses->iface_count; j++) {
443                                 struct cifs_server_iface *iface;
444 
445                                 iface = &ses->iface_list[j];
446                                 seq_printf(m, "\t%d)", j);
447                                 cifs_dump_iface(m, iface);
448                                 if (is_ses_using_iface(ses, iface))
449                                         seq_puts(m, "\t\t[CONNECTED]\n");
450                         }
451                         spin_unlock(&ses->iface_lock);
452                 }
453         }
454         spin_unlock(&cifs_tcp_ses_lock);
455         seq_putc(m, '\n');
456 
457         /* BB add code to dump additional info such as TCP session info now */
458         return 0;
459 }
460 
461 static ssize_t cifs_stats_proc_write(struct file *file,
462                 const char __user *buffer, size_t count, loff_t *ppos)
463 {
464         bool bv;
465         int rc;
466         struct list_head *tmp1, *tmp2, *tmp3;
467         struct TCP_Server_Info *server;
468         struct cifs_ses *ses;
469         struct cifs_tcon *tcon;
470 
471         rc = kstrtobool_from_user(buffer, count, &bv);
472         if (rc == 0) {
473 #ifdef CONFIG_CIFS_STATS2
474                 int i;
475 
476                 atomic_set(&totBufAllocCount, 0);
477                 atomic_set(&totSmBufAllocCount, 0);
478 #endif /* CONFIG_CIFS_STATS2 */
479                 atomic_set(&tcpSesReconnectCount, 0);
480                 atomic_set(&tconInfoReconnectCount, 0);
481 
482                 spin_lock(&GlobalMid_Lock);
483                 GlobalMaxActiveXid = 0;
484                 GlobalCurrentXid = 0;
485                 spin_unlock(&GlobalMid_Lock);
486                 spin_lock(&cifs_tcp_ses_lock);
487                 list_for_each(tmp1, &cifs_tcp_ses_list) {
488                         server = list_entry(tmp1, struct TCP_Server_Info,
489                                             tcp_ses_list);
490                         server->max_in_flight = 0;
491 #ifdef CONFIG_CIFS_STATS2
492                         for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
493                                 atomic_set(&server->num_cmds[i], 0);
494                                 atomic_set(&server->smb2slowcmd[i], 0);
495                                 server->time_per_cmd[i] = 0;
496                                 server->slowest_cmd[i] = 0;
497                                 server->fastest_cmd[0] = 0;
498                         }
499 #endif /* CONFIG_CIFS_STATS2 */
500                         list_for_each(tmp2, &server->smb_ses_list) {
501                                 ses = list_entry(tmp2, struct cifs_ses,
502                                                  smb_ses_list);
503                                 list_for_each(tmp3, &ses->tcon_list) {
504                                         tcon = list_entry(tmp3,
505                                                           struct cifs_tcon,
506                                                           tcon_list);
507                                         atomic_set(&tcon->num_smbs_sent, 0);
508                                         spin_lock(&tcon->stat_lock);
509                                         tcon->bytes_read = 0;
510                                         tcon->bytes_written = 0;
511                                         spin_unlock(&tcon->stat_lock);
512                                         if (server->ops->clear_stats)
513                                                 server->ops->clear_stats(tcon);
514                                 }
515                         }
516                 }
517                 spin_unlock(&cifs_tcp_ses_lock);
518         } else {
519                 return rc;
520         }
521 
522         return count;
523 }
524 
525 static int cifs_stats_proc_show(struct seq_file *m, void *v)
526 {
527         int i;
528 #ifdef CONFIG_CIFS_STATS2
529         int j;
530 #endif /* STATS2 */
531         struct list_head *tmp1, *tmp2, *tmp3;
532         struct TCP_Server_Info *server;
533         struct cifs_ses *ses;
534         struct cifs_tcon *tcon;
535 
536         seq_printf(m, "Resources in use\nCIFS Session: %d\n",
537                         sesInfoAllocCount.counter);
538         seq_printf(m, "Share (unique mount targets): %d\n",
539                         tconInfoAllocCount.counter);
540         seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
541                         bufAllocCount.counter,
542                         cifs_min_rcv + tcpSesAllocCount.counter);
543         seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
544                         smBufAllocCount.counter, cifs_min_small);
545 #ifdef CONFIG_CIFS_STATS2
546         seq_printf(m, "Total Large %d Small %d Allocations\n",
547                                 atomic_read(&totBufAllocCount),
548                                 atomic_read(&totSmBufAllocCount));
549 #endif /* CONFIG_CIFS_STATS2 */
550 
551         seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount));
552         seq_printf(m,
553                 "\n%d session %d share reconnects\n",
554                 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
555 
556         seq_printf(m,
557                 "Total vfs operations: %d maximum at one time: %d\n",
558                 GlobalCurrentXid, GlobalMaxActiveXid);
559 
560         i = 0;
561         spin_lock(&cifs_tcp_ses_lock);
562         list_for_each(tmp1, &cifs_tcp_ses_list) {
563                 server = list_entry(tmp1, struct TCP_Server_Info,
564                                     tcp_ses_list);
565                 seq_printf(m, "\nMax requests in flight: %d", server->max_in_flight);
566 #ifdef CONFIG_CIFS_STATS2
567                 seq_puts(m, "\nTotal time spent processing by command. Time ");
568                 seq_printf(m, "units are jiffies (%d per second)\n", HZ);
569                 seq_puts(m, "  SMB3 CMD\tNumber\tTotal Time\tFastest\tSlowest\n");
570                 seq_puts(m, "  --------\t------\t----------\t-------\t-------\n");
571                 for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++)
572                         seq_printf(m, "  %d\t\t%d\t%llu\t\t%u\t%u\n", j,
573                                 atomic_read(&server->num_cmds[j]),
574                                 server->time_per_cmd[j],
575                                 server->fastest_cmd[j],
576                                 server->slowest_cmd[j]);
577                 for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++)
578                         if (atomic_read(&server->smb2slowcmd[j]))
579                                 seq_printf(m, "  %d slow responses from %s for command %d\n",
580                                         atomic_read(&server->smb2slowcmd[j]),
581                                         server->hostname, j);
582 #endif /* STATS2 */
583                 list_for_each(tmp2, &server->smb_ses_list) {
584                         ses = list_entry(tmp2, struct cifs_ses,
585                                          smb_ses_list);
586                         list_for_each(tmp3, &ses->tcon_list) {
587                                 tcon = list_entry(tmp3,
588                                                   struct cifs_tcon,
589                                                   tcon_list);
590                                 i++;
591                                 seq_printf(m, "\n%d) %s", i, tcon->treeName);
592                                 if (tcon->need_reconnect)
593                                         seq_puts(m, "\tDISCONNECTED ");
594                                 seq_printf(m, "\nSMBs: %d",
595                                            atomic_read(&tcon->num_smbs_sent));
596                                 if (server->ops->print_stats)
597                                         server->ops->print_stats(m, tcon);
598                         }
599                 }
600         }
601         spin_unlock(&cifs_tcp_ses_lock);
602 
603         seq_putc(m, '\n');
604         return 0;
605 }
606 
607 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
608 {
609         return single_open(file, cifs_stats_proc_show, NULL);
610 }
611 
612 static const struct proc_ops cifs_stats_proc_ops = {
613         .proc_open      = cifs_stats_proc_open,
614         .proc_read      = seq_read,
615         .proc_lseek     = seq_lseek,
616         .proc_release   = single_release,
617         .proc_write     = cifs_stats_proc_write,
618 };
619 
620 #ifdef CONFIG_CIFS_SMB_DIRECT
621 #define PROC_FILE_DEFINE(name) \
622 static ssize_t name##_write(struct file *file, const char __user *buffer, \
623         size_t count, loff_t *ppos) \
624 { \
625         int rc; \
626         rc = kstrtoint_from_user(buffer, count, 10, & name); \
627         if (rc) \
628                 return rc; \
629         return count; \
630 } \
631 static int name##_proc_show(struct seq_file *m, void *v) \
632 { \
633         seq_printf(m, "%d\n", name ); \
634         return 0; \
635 } \
636 static int name##_open(struct inode *inode, struct file *file) \
637 { \
638         return single_open(file, name##_proc_show, NULL); \
639 } \
640 \
641 static const struct proc_ops cifs_##name##_proc_fops = { \
642         .proc_open      = name##_open, \
643         .proc_read      = seq_read, \
644         .proc_lseek     = seq_lseek, \
645         .proc_release   = single_release, \
646         .proc_write     = name##_write, \
647 }
648 
649 PROC_FILE_DEFINE(rdma_readwrite_threshold);
650 PROC_FILE_DEFINE(smbd_max_frmr_depth);
651 PROC_FILE_DEFINE(smbd_keep_alive_interval);
652 PROC_FILE_DEFINE(smbd_max_receive_size);
653 PROC_FILE_DEFINE(smbd_max_fragmented_recv_size);
654 PROC_FILE_DEFINE(smbd_max_send_size);
655 PROC_FILE_DEFINE(smbd_send_credit_target);
656 PROC_FILE_DEFINE(smbd_receive_credit_max);
657 #endif
658 
659 static struct proc_dir_entry *proc_fs_cifs;
660 static const struct proc_ops cifsFYI_proc_ops;
661 static const struct proc_ops cifs_lookup_cache_proc_ops;
662 static const struct proc_ops traceSMB_proc_ops;
663 static const struct proc_ops cifs_security_flags_proc_ops;
664 static const struct proc_ops cifs_linux_ext_proc_ops;
665 
666 void
667 cifs_proc_init(void)
668 {
669         proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
670         if (proc_fs_cifs == NULL)
671                 return;
672 
673         proc_create_single("DebugData", 0, proc_fs_cifs,
674                         cifs_debug_data_proc_show);
675 
676         proc_create_single("open_files", 0400, proc_fs_cifs,
677                         cifs_debug_files_proc_show);
678 
679         proc_create("Stats", 0644, proc_fs_cifs, &cifs_stats_proc_ops);
680         proc_create("cifsFYI", 0644, proc_fs_cifs, &cifsFYI_proc_ops);
681         proc_create("traceSMB", 0644, proc_fs_cifs, &traceSMB_proc_ops);
682         proc_create("LinuxExtensionsEnabled", 0644, proc_fs_cifs,
683                     &cifs_linux_ext_proc_ops);
684         proc_create("SecurityFlags", 0644, proc_fs_cifs,
685                     &cifs_security_flags_proc_ops);
686         proc_create("LookupCacheEnabled", 0644, proc_fs_cifs,
687                     &cifs_lookup_cache_proc_ops);
688 
689 #ifdef CONFIG_CIFS_DFS_UPCALL
690         proc_create("dfscache", 0644, proc_fs_cifs, &dfscache_proc_ops);
691 #endif
692 
693 #ifdef CONFIG_CIFS_SMB_DIRECT
694         proc_create("rdma_readwrite_threshold", 0644, proc_fs_cifs,
695                 &cifs_rdma_readwrite_threshold_proc_fops);
696         proc_create("smbd_max_frmr_depth", 0644, proc_fs_cifs,
697                 &cifs_smbd_max_frmr_depth_proc_fops);
698         proc_create("smbd_keep_alive_interval", 0644, proc_fs_cifs,
699                 &cifs_smbd_keep_alive_interval_proc_fops);
700         proc_create("smbd_max_receive_size", 0644, proc_fs_cifs,
701                 &cifs_smbd_max_receive_size_proc_fops);
702         proc_create("smbd_max_fragmented_recv_size", 0644, proc_fs_cifs,
703                 &cifs_smbd_max_fragmented_recv_size_proc_fops);
704         proc_create("smbd_max_send_size", 0644, proc_fs_cifs,
705                 &cifs_smbd_max_send_size_proc_fops);
706         proc_create("smbd_send_credit_target", 0644, proc_fs_cifs,
707                 &cifs_smbd_send_credit_target_proc_fops);
708         proc_create("smbd_receive_credit_max", 0644, proc_fs_cifs,
709                 &cifs_smbd_receive_credit_max_proc_fops);
710 #endif
711 }
712 
713 void
714 cifs_proc_clean(void)
715 {
716         if (proc_fs_cifs == NULL)
717                 return;
718 
719         remove_proc_entry("DebugData", proc_fs_cifs);
720         remove_proc_entry("open_files", proc_fs_cifs);
721         remove_proc_entry("cifsFYI", proc_fs_cifs);
722         remove_proc_entry("traceSMB", proc_fs_cifs);
723         remove_proc_entry("Stats", proc_fs_cifs);
724         remove_proc_entry("SecurityFlags", proc_fs_cifs);
725         remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
726         remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
727 
728 #ifdef CONFIG_CIFS_DFS_UPCALL
729         remove_proc_entry("dfscache", proc_fs_cifs);
730 #endif
731 #ifdef CONFIG_CIFS_SMB_DIRECT
732         remove_proc_entry("rdma_readwrite_threshold", proc_fs_cifs);
733         remove_proc_entry("smbd_max_frmr_depth", proc_fs_cifs);
734         remove_proc_entry("smbd_keep_alive_interval", proc_fs_cifs);
735         remove_proc_entry("smbd_max_receive_size", proc_fs_cifs);
736         remove_proc_entry("smbd_max_fragmented_recv_size", proc_fs_cifs);
737         remove_proc_entry("smbd_max_send_size", proc_fs_cifs);
738         remove_proc_entry("smbd_send_credit_target", proc_fs_cifs);
739         remove_proc_entry("smbd_receive_credit_max", proc_fs_cifs);
740 #endif
741         remove_proc_entry("fs/cifs", NULL);
742 }
743 
744 static int cifsFYI_proc_show(struct seq_file *m, void *v)
745 {
746         seq_printf(m, "%d\n", cifsFYI);
747         return 0;
748 }
749 
750 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
751 {
752         return single_open(file, cifsFYI_proc_show, NULL);
753 }
754 
755 static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
756                 size_t count, loff_t *ppos)
757 {
758         char c[2] = { '\0' };
759         bool bv;
760         int rc;
761 
762         rc = get_user(c[0], buffer);
763         if (rc)
764                 return rc;
765         if (strtobool(c, &bv) == 0)
766                 cifsFYI = bv;
767         else if ((c[0] > '1') && (c[0] <= '9'))
768                 cifsFYI = (int) (c[0] - ''); /* see cifs_debug.h for meanings */
769         else
770                 return -EINVAL;
771 
772         return count;
773 }
774 
775 static const struct proc_ops cifsFYI_proc_ops = {
776         .proc_open      = cifsFYI_proc_open,
777         .proc_read      = seq_read,
778         .proc_lseek     = seq_lseek,
779         .proc_release   = single_release,
780         .proc_write     = cifsFYI_proc_write,
781 };
782 
783 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
784 {
785         seq_printf(m, "%d\n", linuxExtEnabled);
786         return 0;
787 }
788 
789 static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
790 {
791         return single_open(file, cifs_linux_ext_proc_show, NULL);
792 }
793 
794 static ssize_t cifs_linux_ext_proc_write(struct file *file,
795                 const char __user *buffer, size_t count, loff_t *ppos)
796 {
797         int rc;
798 
799         rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled);
800         if (rc)
801                 return rc;
802 
803         return count;
804 }
805 
806 static const struct proc_ops cifs_linux_ext_proc_ops = {
807         .proc_open      = cifs_linux_ext_proc_open,
808         .proc_read      = seq_read,
809         .proc_lseek     = seq_lseek,
810         .proc_release   = single_release,
811         .proc_write     = cifs_linux_ext_proc_write,
812 };
813 
814 static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
815 {
816         seq_printf(m, "%d\n", lookupCacheEnabled);
817         return 0;
818 }
819 
820 static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
821 {
822         return single_open(file, cifs_lookup_cache_proc_show, NULL);
823 }
824 
825 static ssize_t cifs_lookup_cache_proc_write(struct file *file,
826                 const char __user *buffer, size_t count, loff_t *ppos)
827 {
828         int rc;
829 
830         rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled);
831         if (rc)
832                 return rc;
833 
834         return count;
835 }
836 
837 static const struct proc_ops cifs_lookup_cache_proc_ops = {
838         .proc_open      = cifs_lookup_cache_proc_open,
839         .proc_read      = seq_read,
840         .proc_lseek     = seq_lseek,
841         .proc_release   = single_release,
842         .proc_write     = cifs_lookup_cache_proc_write,
843 };
844 
845 static int traceSMB_proc_show(struct seq_file *m, void *v)
846 {
847         seq_printf(m, "%d\n", traceSMB);
848         return 0;
849 }
850 
851 static int traceSMB_proc_open(struct inode *inode, struct file *file)
852 {
853         return single_open(file, traceSMB_proc_show, NULL);
854 }
855 
856 static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
857                 size_t count, loff_t *ppos)
858 {
859         int rc;
860 
861         rc = kstrtobool_from_user(buffer, count, &traceSMB);
862         if (rc)
863                 return rc;
864 
865         return count;
866 }
867 
868 static const struct proc_ops traceSMB_proc_ops = {
869         .proc_open      = traceSMB_proc_open,
870         .proc_read      = seq_read,
871         .proc_lseek     = seq_lseek,
872         .proc_release   = single_release,
873         .proc_write     = traceSMB_proc_write,
874 };
875 
876 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
877 {
878         seq_printf(m, "0x%x\n", global_secflags);
879         return 0;
880 }
881 
882 static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
883 {
884         return single_open(file, cifs_security_flags_proc_show, NULL);
885 }
886 
887 /*
888  * Ensure that if someone sets a MUST flag, that we disable all other MAY
889  * flags except for the ones corresponding to the given MUST flag. If there are
890  * multiple MUST flags, then try to prefer more secure ones.
891  */
892 static void
893 cifs_security_flags_handle_must_flags(unsigned int *flags)
894 {
895         unsigned int signflags = *flags & CIFSSEC_MUST_SIGN;
896 
897         if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
898                 *flags = CIFSSEC_MUST_KRB5;
899         else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
900                 *flags = CIFSSEC_MUST_NTLMSSP;
901         else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
902                 *flags = CIFSSEC_MUST_NTLMV2;
903         else if ((*flags & CIFSSEC_MUST_NTLM) == CIFSSEC_MUST_NTLM)
904                 *flags = CIFSSEC_MUST_NTLM;
905         else if (CIFSSEC_MUST_LANMAN &&
906                  (*flags & CIFSSEC_MUST_LANMAN) == CIFSSEC_MUST_LANMAN)
907                 *flags = CIFSSEC_MUST_LANMAN;
908         else if (CIFSSEC_MUST_PLNTXT &&
909                  (*flags & CIFSSEC_MUST_PLNTXT) == CIFSSEC_MUST_PLNTXT)
910                 *flags = CIFSSEC_MUST_PLNTXT;
911 
912         *flags |= signflags;
913 }
914 
915 static ssize_t cifs_security_flags_proc_write(struct file *file,
916                 const char __user *buffer, size_t count, loff_t *ppos)
917 {
918         int rc;
919         unsigned int flags;
920         char flags_string[12];
921         bool bv;
922 
923         if ((count < 1) || (count > 11))
924                 return -EINVAL;
925 
926         memset(flags_string, 0, 12);
927 
928         if (copy_from_user(flags_string, buffer, count))
929                 return -EFAULT;
930 
931         if (count < 3) {
932                 /* single char or single char followed by null */
933                 if (strtobool(flags_string, &bv) == 0) {
934                         global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF;
935                         return count;
936                 } else if (!isdigit(flags_string[0])) {
937                         cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
938                                         flags_string);
939                         return -EINVAL;
940                 }
941         }
942 
943         /* else we have a number */
944         rc = kstrtouint(flags_string, 0, &flags);
945         if (rc) {
946                 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
947                                 flags_string);
948                 return rc;
949         }
950 
951         cifs_dbg(FYI, "sec flags 0x%x\n", flags);
952 
953         if (flags == 0)  {
954                 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string);
955                 return -EINVAL;
956         }
957 
958         if (flags & ~CIFSSEC_MASK) {
959                 cifs_dbg(VFS, "Unsupported security flags: 0x%x\n",
960                          flags & ~CIFSSEC_MASK);
961                 return -EINVAL;
962         }
963 
964         cifs_security_flags_handle_must_flags(&flags);
965 
966         /* flags look ok - update the global security flags for cifs module */
967         global_secflags = flags;
968         if (global_secflags & CIFSSEC_MUST_SIGN) {
969                 /* requiring signing implies signing is allowed */
970                 global_secflags |= CIFSSEC_MAY_SIGN;
971                 cifs_dbg(FYI, "packet signing now required\n");
972         } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) {
973                 cifs_dbg(FYI, "packet signing disabled\n");
974         }
975         /* BB should we turn on MAY flags for other MUST options? */
976         return count;
977 }
978 
979 static const struct proc_ops cifs_security_flags_proc_ops = {
980         .proc_open      = cifs_security_flags_proc_open,
981         .proc_read      = seq_read,
982         .proc_lseek     = seq_lseek,
983         .proc_release   = single_release,
984         .proc_write     = cifs_security_flags_proc_write,
985 };
986 #else
987 inline void cifs_proc_init(void)
988 {
989 }
990 
991 inline void cifs_proc_clean(void)
992 {
993 }
994 #endif /* PROC_FS */
995 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp