fs/smb/client/cifs_debug.c

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