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                 if (server->rdma)
 442                         seq_printf(m, "\nRDMA ");
 443                 seq_printf(m, "\nTCP status: %d Instance: %d"
 444                                 "\nLocal Users To Server: %d SecMode: 0x%x Req On Wire: %d",
 445                                 server->tcpStatus,
 446                                 server->reconnect_instance,
 447                                 server->srv_count,
 448                                 server->sec_mode, in_flight(server));
 449 #ifdef CONFIG_NET_NS
 450                 if (server->net)
 451                         seq_printf(m, " Net namespace: %u ", server->net->ns.inum);
 452 #endif /* NET_NS */
 453
 454                 seq_printf(m, "\nIn Send: %d In MaxReq Wait: %d",
 455                                 atomic_read(&server->in_send),
 456                                 atomic_read(&server->num_waiters));
 457
 458                 if (server->leaf_fullpath) {
 459                         seq_printf(m, "\nDFS leaf full path: %s",
 460                                    server->leaf_fullpath);
 461                 }
 462
 463                 seq_printf(m, "\n\n\tSessions: ");
 464                 i = 0;
 465                 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
 466                         spin_lock(&ses->ses_lock);
 467                         if (ses->ses_status == SES_EXITING) {
 468                                 spin_unlock(&ses->ses_lock);
 469                                 continue;
 470                         }
 471                         i++;
 472                         if ((ses->serverDomain == NULL) ||
 473                                 (ses->serverOS == NULL) ||
 474                                 (ses->serverNOS == NULL)) {
 475                                 seq_printf(m, "\n\t%d) Address: %s Uses: %d Capability: 0x%x\tSession Status: %d ",
 476                                         i, ses->ip_addr, ses->ses_count,
 477                                         ses->capabilities, ses->ses_status);
 478                                 if (ses->session_flags & SMB2_SESSION_FLAG_IS_GUEST)
 479                                         seq_printf(m, "Guest ");
 480                                 else if (ses->session_flags & SMB2_SESSION_FLAG_IS_NULL)
 481                                         seq_printf(m, "Anonymous ");
 482                         } else {
 483                                 seq_printf(m,
 484                                     "\n\t%d) Name: %s  Domain: %s Uses: %d OS: %s "
 485                                     "\n\tNOS: %s\tCapability: 0x%x"
 486                                         "\n\tSMB session status: %d ",
 487                                 i, ses->ip_addr, ses->serverDomain,
 488                                 ses->ses_count, ses->serverOS, ses->serverNOS,
 489                                 ses->capabilities, ses->ses_status);
 490                         }
 491                         if (ses->expired_pwd)
 492                                 seq_puts(m, "password no longer valid ");
 493                         spin_unlock(&ses->ses_lock);
 494
 495                         seq_printf(m, "\n\tSecurity type: %s ",
 496                                 get_security_type_str(server->ops->select_sectype(server, ses->sectype)));
 497
 498                         /* dump session id helpful for use with network trace */
 499                         seq_printf(m, " SessionId: 0x%llx", ses->Suid);
 500                         if (ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) {
 501                                 seq_puts(m, " encrypted");
 502                                 /* can help in debugging to show encryption type */
 503                                 if (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)
 504                                         seq_puts(m, "(gcm256)");
 505                         }
 506                         if (ses->sign)
 507                                 seq_puts(m, " signed");
 508
 509                         seq_printf(m, "\n\tUser: %d Cred User: %d",
 510                                    from_kuid(&init_user_ns, ses->linux_uid),
 511                                    from_kuid(&init_user_ns, ses->cred_uid));
 512
 513                         if (ses->dfs_root_ses) {
 514                                 seq_printf(m, "\n\tDFS root session id: 0x%llx",
 515                                            ses->dfs_root_ses->Suid);
 516                         }
 517
 518                         spin_lock(&ses->chan_lock);
 519                         if (CIFS_CHAN_NEEDS_RECONNECT(ses, 0))
 520                                 seq_puts(m, "\tPrimary channel: DISCONNECTED ");
 521                         if (CIFS_CHAN_IN_RECONNECT(ses, 0))
 522                                 seq_puts(m, "\t[RECONNECTING] ");
 523
 524                         if (ses->chan_count > 1) {
 525                                 seq_printf(m, "\n\n\tExtra Channels: %zu ",
 526                                            ses->chan_count-1);
 527                                 for (j = 1; j < ses->chan_count; j++) {
 528                                         cifs_dump_channel(m, j, &ses->chans[j]);
 529                                         if (CIFS_CHAN_NEEDS_RECONNECT(ses, j))
 530                                                 seq_puts(m, "\tDISCONNECTED ");
 531                                         if (CIFS_CHAN_IN_RECONNECT(ses, j))
 532                                                 seq_puts(m, "\t[RECONNECTING] ");
 533                                 }
 534                         }
 535                         spin_unlock(&ses->chan_lock);
 536
 537                         seq_puts(m, "\n\n\tShares: ");
 538                         j = 0;
 539
 540                         seq_printf(m, "\n\t%d) IPC: ", j);
 541                         if (ses->tcon_ipc)
 542                                 cifs_debug_tcon(m, ses->tcon_ipc);
 543                         else
 544                                 seq_puts(m, "none\n");
 545
 546                         list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
 547                                 ++j;
 548                                 seq_printf(m, "\n\t%d) ", j);
 549                                 cifs_debug_tcon(m, tcon);
 550                         }
 551
 552                         spin_lock(&ses->iface_lock);
 553                         if (ses->iface_count)
 554                                 seq_printf(m, "\n\n\tServer interfaces: %zu"
 555                                            "\tLast updated: %lu seconds ago",
 556                                            ses->iface_count,
 557                                            (jiffies - ses->iface_last_update) / HZ);
 558
 559                         last_iface = list_last_entry(&ses->iface_list,
 560                                                      struct cifs_server_iface,
 561                                                      iface_head);
 562                         iface_min_speed = last_iface->speed;
 563
 564                         j = 0;
 565                         list_for_each_entry(iface, &ses->iface_list,
 566                                                  iface_head) {
 567                                 seq_printf(m, "\n\t%d)", ++j);
 568                                 cifs_dump_iface(m, iface);
 569
 570                                 iface_weight = iface->speed / iface_min_speed;
 571                                 seq_printf(m, "\t\tWeight (cur,total): (%zu,%zu)"
 572                                            "\n\t\tAllocated channels: %u\n",
 573                                            iface->weight_fulfilled,
 574                                            iface_weight,
 575                                            iface->num_channels);
 576
 577                                 if (is_ses_using_iface(ses, iface))
 578                                         seq_puts(m, "\t\t[CONNECTED]\n");
 579                         }
 580                         spin_unlock(&ses->iface_lock);
 581
 582                         seq_puts(m, "\n\n\tMIDs: ");
 583                         spin_lock(&ses->chan_lock);
 584                         for (j = 0; j < ses->chan_count; j++) {
 585                                 chan_server = ses->chans[j].server;
 586                                 if (!chan_server)
 587                                         continue;
 588
 589                                 if (list_empty(&chan_server->pending_mid_q))
 590                                         continue;
 591
 592                                 seq_printf(m, "\n\tServer ConnectionId: 0x%llx",
 593                                            chan_server->conn_id);
 594                                 spin_lock(&chan_server->mid_lock);
 595                                 list_for_each_entry(mid_entry, &chan_server->pending_mid_q, qhead) {
 596                                         seq_printf(m, "\n\t\tState: %d com: %d pid: %d cbdata: %p mid %llu",
 597                                                    mid_entry->mid_state,
 598                                                    le16_to_cpu(mid_entry->command),
 599                                                    mid_entry->pid,
 600                                                    mid_entry->callback_data,
 601                                                    mid_entry->mid);
 602                                 }
 603                                 spin_unlock(&chan_server->mid_lock);
 604                         }
 605                         spin_unlock(&ses->chan_lock);
 606                         seq_puts(m, "\n--\n");
 607                 }
 608                 if (i == 0)
 609                         seq_printf(m, "\n\t\t[NONE]");
 610         }
 611         if (c == 0)
 612                 seq_printf(m, "\n\t[NONE]");
 613
 614         spin_unlock(&cifs_tcp_ses_lock);
 615         seq_putc(m, '\n');
 616         cifs_swn_dump(m);
 617
 618         /* BB add code to dump additional info such as TCP session info now */
 619         return 0;
 620 }
 621
 622 static ssize_t cifs_stats_proc_write(struct file *file,
 623                 const char __user *buffer, size_t count, loff_t *ppos)
 624 {
 625         bool bv;
 626         int rc;
 627         struct TCP_Server_Info *server;
 628         struct cifs_ses *ses;
 629         struct cifs_tcon *tcon;
 630
 631         rc = kstrtobool_from_user(buffer, count, &bv);
 632         if (rc == 0) {
 633 #ifdef CONFIG_CIFS_STATS2
 634                 int i;
 635
 636                 atomic_set(&total_buf_alloc_count, 0);
 637                 atomic_set(&total_small_buf_alloc_count, 0);
 638 #endif /* CONFIG_CIFS_STATS2 */
 639                 atomic_set(&tcpSesReconnectCount, 0);
 640                 atomic_set(&tconInfoReconnectCount, 0);
 641
 642                 spin_lock(&GlobalMid_Lock);
 643                 GlobalMaxActiveXid = 0;
 644                 GlobalCurrentXid = 0;
 645                 spin_unlock(&GlobalMid_Lock);
 646                 spin_lock(&cifs_tcp_ses_lock);
 647                 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
 648                         server->max_in_flight = 0;
 649 #ifdef CONFIG_CIFS_STATS2
 650                         for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
 651                                 atomic_set(&server->num_cmds[i], 0);
 652                                 atomic_set(&server->smb2slowcmd[i], 0);
 653                                 server->time_per_cmd[i] = 0;
 654                                 server->slowest_cmd[i] = 0;
 655                                 server->fastest_cmd[0] = 0;
 656                         }
 657 #endif /* CONFIG_CIFS_STATS2 */
 658                         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
 659                                 if (cifs_ses_exiting(ses))
 660                                         continue;
 661                                 list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
 662                                         atomic_set(&tcon->num_smbs_sent, 0);
 663                                         spin_lock(&tcon->stat_lock);
 664                                         tcon->bytes_read = 0;
 665                                         tcon->bytes_written = 0;
 666                                         spin_unlock(&tcon->stat_lock);
 667                                         if (server->ops->clear_stats)
 668                                                 server->ops->clear_stats(tcon);
 669                                 }
 670                         }
 671                 }
 672                 spin_unlock(&cifs_tcp_ses_lock);
 673         } else {
 674                 return rc;
 675         }
 676
 677         return count;
 678 }
 679
 680 static int cifs_stats_proc_show(struct seq_file *m, void *v)
 681 {
 682         int i;
 683 #ifdef CONFIG_CIFS_STATS2
 684         int j;
 685 #endif /* STATS2 */
 686         struct TCP_Server_Info *server;
 687         struct cifs_ses *ses;
 688         struct cifs_tcon *tcon;
 689
 690         seq_printf(m, "Resources in use\nCIFS Session: %d\n",
 691                         sesInfoAllocCount.counter);
 692         seq_printf(m, "Share (unique mount targets): %d\n",
 693                         tconInfoAllocCount.counter);
 694         seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
 695                         buf_alloc_count.counter,
 696                         cifs_min_rcv + tcpSesAllocCount.counter);
 697         seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
 698                         small_buf_alloc_count.counter, cifs_min_small);
 699 #ifdef CONFIG_CIFS_STATS2
 700         seq_printf(m, "Total Large %d Small %d Allocations\n",
 701                                 atomic_read(&total_buf_alloc_count),
 702                                 atomic_read(&total_small_buf_alloc_count));
 703 #endif /* CONFIG_CIFS_STATS2 */
 704
 705         seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&mid_count));
 706         seq_printf(m,
 707                 "\n%d session %d share reconnects\n",
 708                 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
 709
 710         seq_printf(m,
 711                 "Total vfs operations: %d maximum at one time: %d\n",
 712                 GlobalCurrentXid, GlobalMaxActiveXid);
 713
 714         i = 0;
 715         spin_lock(&cifs_tcp_ses_lock);
 716         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
 717                 seq_printf(m, "\nMax requests in flight: %d", server->max_in_flight);
 718 #ifdef CONFIG_CIFS_STATS2
 719                 seq_puts(m, "\nTotal time spent processing by command. Time ");
 720                 seq_printf(m, "units are jiffies (%d per second)\n", HZ);
 721                 seq_puts(m, "  SMB3 CMD\tNumber\tTotal Time\tFastest\tSlowest\n");
 722                 seq_puts(m, "  --------\t------\t----------\t-------\t-------\n");
 723                 for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++)
 724                         seq_printf(m, "  %d\t\t%d\t%llu\t\t%u\t%u\n", j,
 725                                 atomic_read(&server->num_cmds[j]),
 726                                 server->time_per_cmd[j],
 727                                 server->fastest_cmd[j],
 728                                 server->slowest_cmd[j]);
 729                 for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++)
 730                         if (atomic_read(&server->smb2slowcmd[j])) {
 731                                 spin_lock(&server->srv_lock);
 732                                 seq_printf(m, "  %d slow responses from %s for command %d\n",
 733                                         atomic_read(&server->smb2slowcmd[j]),
 734                                         server->hostname, j);
 735                                 spin_unlock(&server->srv_lock);
 736                         }
 737 #endif /* STATS2 */
 738                 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
 739                         if (cifs_ses_exiting(ses))
 740                                 continue;
 741                         list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
 742                                 i++;
 743                                 seq_printf(m, "\n%d) %s", i, tcon->tree_name);
 744                                 if (tcon->need_reconnect)
 745                                         seq_puts(m, "\tDISCONNECTED ");
 746                                 seq_printf(m, "\nSMBs: %d",
 747                                            atomic_read(&tcon->num_smbs_sent));
 748                                 if (server->ops->print_stats)
 749                                         server->ops->print_stats(m, tcon);
 750                         }
 751                 }
 752         }
 753         spin_unlock(&cifs_tcp_ses_lock);
 754
 755         seq_putc(m, '\n');
 756         return 0;
 757 }
 758
 759 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
 760 {
 761         return single_open(file, cifs_stats_proc_show, NULL);
 762 }
 763
 764 static const struct proc_ops cifs_stats_proc_ops = {
 765         .proc_open      = cifs_stats_proc_open,
 766         .proc_read      = seq_read,
 767         .proc_lseek     = seq_lseek,
 768         .proc_release   = single_release,
 769         .proc_write     = cifs_stats_proc_write,
 770 };
 771
 772 #ifdef CONFIG_CIFS_SMB_DIRECT
 773 #define PROC_FILE_DEFINE(name) \
 774 static ssize_t name##_write(struct file *file, const char __user *buffer, \
 775         size_t count, loff_t *ppos) \
 776 { \
 777         int rc; \
 778         rc = kstrtoint_from_user(buffer, count, 10, & name); \
 779         if (rc) \
 780                 return rc; \
 781         return count; \
 782 } \
 783 static int name##_proc_show(struct seq_file *m, void *v) \
 784 { \
 785         seq_printf(m, "%d\n", name ); \
 786         return 0; \
 787 } \
 788 static int name##_open(struct inode *inode, struct file *file) \
 789 { \
 790         return single_open(file, name##_proc_show, NULL); \
 791 } \
 792 \
 793 static const struct proc_ops cifs_##name##_proc_fops = { \
 794         .proc_open      = name##_open, \
 795         .proc_read      = seq_read, \
 796         .proc_lseek     = seq_lseek, \
 797         .proc_release   = single_release, \
 798         .proc_write     = name##_write, \
 799 }
 800
 801 PROC_FILE_DEFINE(rdma_readwrite_threshold);
 802 PROC_FILE_DEFINE(smbd_max_frmr_depth);
 803 PROC_FILE_DEFINE(smbd_keep_alive_interval);
 804 PROC_FILE_DEFINE(smbd_max_receive_size);
 805 PROC_FILE_DEFINE(smbd_max_fragmented_recv_size);
 806 PROC_FILE_DEFINE(smbd_max_send_size);
 807 PROC_FILE_DEFINE(smbd_send_credit_target);
 808 PROC_FILE_DEFINE(smbd_receive_credit_max);
 809 #endif
 810
 811 static struct proc_dir_entry *proc_fs_cifs;
 812 static const struct proc_ops cifsFYI_proc_ops;
 813 static const struct proc_ops cifs_lookup_cache_proc_ops;
 814 static const struct proc_ops traceSMB_proc_ops;
 815 static const struct proc_ops cifs_security_flags_proc_ops;
 816 static const struct proc_ops cifs_linux_ext_proc_ops;
 817 static const struct proc_ops cifs_mount_params_proc_ops;
 818
 819 void
 820 cifs_proc_init(void)
 821 {
 822         proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
 823         if (proc_fs_cifs == NULL)
 824                 return;
 825
 826         proc_create_single("DebugData", 0, proc_fs_cifs,
 827                         cifs_debug_data_proc_show);
 828
 829         proc_create_single("open_files", 0400, proc_fs_cifs,
 830                         cifs_debug_files_proc_show);
 831
 832         proc_create("Stats", 0644, proc_fs_cifs, &cifs_stats_proc_ops);
 833         proc_create("cifsFYI", 0644, proc_fs_cifs, &cifsFYI_proc_ops);
 834         proc_create("traceSMB", 0644, proc_fs_cifs, &traceSMB_proc_ops);
 835         proc_create("LinuxExtensionsEnabled", 0644, proc_fs_cifs,
 836                     &cifs_linux_ext_proc_ops);
 837         proc_create("SecurityFlags", 0644, proc_fs_cifs,
 838                     &cifs_security_flags_proc_ops);
 839         proc_create("LookupCacheEnabled", 0644, proc_fs_cifs,
 840                     &cifs_lookup_cache_proc_ops);
 841
 842         proc_create("mount_params", 0444, proc_fs_cifs, &cifs_mount_params_proc_ops);
 843
 844 #ifdef CONFIG_CIFS_DFS_UPCALL
 845         proc_create("dfscache", 0644, proc_fs_cifs, &dfscache_proc_ops);
 846 #endif
 847
 848 #ifdef CONFIG_CIFS_SMB_DIRECT
 849         proc_create("rdma_readwrite_threshold", 0644, proc_fs_cifs,
 850                 &cifs_rdma_readwrite_threshold_proc_fops);
 851         proc_create("smbd_max_frmr_depth", 0644, proc_fs_cifs,
 852                 &cifs_smbd_max_frmr_depth_proc_fops);
 853         proc_create("smbd_keep_alive_interval", 0644, proc_fs_cifs,
 854                 &cifs_smbd_keep_alive_interval_proc_fops);
 855         proc_create("smbd_max_receive_size", 0644, proc_fs_cifs,
 856                 &cifs_smbd_max_receive_size_proc_fops);
 857         proc_create("smbd_max_fragmented_recv_size", 0644, proc_fs_cifs,
 858                 &cifs_smbd_max_fragmented_recv_size_proc_fops);
 859         proc_create("smbd_max_send_size", 0644, proc_fs_cifs,
 860                 &cifs_smbd_max_send_size_proc_fops);
 861         proc_create("smbd_send_credit_target", 0644, proc_fs_cifs,
 862                 &cifs_smbd_send_credit_target_proc_fops);
 863         proc_create("smbd_receive_credit_max", 0644, proc_fs_cifs,
 864                 &cifs_smbd_receive_credit_max_proc_fops);
 865 #endif
 866 }
 867
 868 void
 869 cifs_proc_clean(void)
 870 {
 871         if (proc_fs_cifs == NULL)
 872                 return;
 873
 874         remove_proc_entry("DebugData", proc_fs_cifs);
 875         remove_proc_entry("open_files", proc_fs_cifs);
 876         remove_proc_entry("cifsFYI", proc_fs_cifs);
 877         remove_proc_entry("traceSMB", proc_fs_cifs);
 878         remove_proc_entry("Stats", proc_fs_cifs);
 879         remove_proc_entry("SecurityFlags", proc_fs_cifs);
 880         remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
 881         remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
 882         remove_proc_entry("mount_params", proc_fs_cifs);
 883
 884 #ifdef CONFIG_CIFS_DFS_UPCALL
 885         remove_proc_entry("dfscache", proc_fs_cifs);
 886 #endif
 887 #ifdef CONFIG_CIFS_SMB_DIRECT
 888         remove_proc_entry("rdma_readwrite_threshold", proc_fs_cifs);
 889         remove_proc_entry("smbd_max_frmr_depth", proc_fs_cifs);
 890         remove_proc_entry("smbd_keep_alive_interval", proc_fs_cifs);
 891         remove_proc_entry("smbd_max_receive_size", proc_fs_cifs);
 892         remove_proc_entry("smbd_max_fragmented_recv_size", proc_fs_cifs);
 893         remove_proc_entry("smbd_max_send_size", proc_fs_cifs);
 894         remove_proc_entry("smbd_send_credit_target", proc_fs_cifs);
 895         remove_proc_entry("smbd_receive_credit_max", proc_fs_cifs);
 896 #endif
 897         remove_proc_entry("fs/cifs", NULL);
 898 }
 899
 900 static int cifsFYI_proc_show(struct seq_file *m, void *v)
 901 {
 902         seq_printf(m, "%d\n", cifsFYI);
 903         return 0;
 904 }
 905
 906 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
 907 {
 908         return single_open(file, cifsFYI_proc_show, NULL);
 909 }
 910
 911 static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
 912                 size_t count, loff_t *ppos)
 913 {
 914         char c[2] = { '\0' };
 915         bool bv;
 916         int rc;
 917
 918         rc = get_user(c[0], buffer);
 919         if (rc)
 920                 return rc;
 921         if (kstrtobool(c, &bv) == 0)
 922                 cifsFYI = bv;
 923         else if ((c[0] > '1') && (c[0] <= '9'))
 924                 cifsFYI = (int) (c[0] - '0'); /* see cifs_debug.h for meanings */
 925         else
 926                 return -EINVAL;
 927
 928         return count;
 929 }
 930
 931 static const struct proc_ops cifsFYI_proc_ops = {
 932         .proc_open      = cifsFYI_proc_open,
 933         .proc_read      = seq_read,
 934         .proc_lseek     = seq_lseek,
 935         .proc_release   = single_release,
 936         .proc_write     = cifsFYI_proc_write,
 937 };
 938
 939 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
 940 {
 941         seq_printf(m, "%d\n", linuxExtEnabled);
 942         return 0;
 943 }
 944
 945 static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
 946 {
 947         return single_open(file, cifs_linux_ext_proc_show, NULL);
 948 }
 949
 950 static ssize_t cifs_linux_ext_proc_write(struct file *file,
 951                 const char __user *buffer, size_t count, loff_t *ppos)
 952 {
 953         int rc;
 954
 955         rc = kstrtobool_from_user(buffer, count, &linuxExtEnabled);
 956         if (rc)
 957                 return rc;
 958
 959         return count;
 960 }
 961
 962 static const struct proc_ops cifs_linux_ext_proc_ops = {
 963         .proc_open      = cifs_linux_ext_proc_open,
 964         .proc_read      = seq_read,
 965         .proc_lseek     = seq_lseek,
 966         .proc_release   = single_release,
 967         .proc_write     = cifs_linux_ext_proc_write,
 968 };
 969
 970 static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
 971 {
 972         seq_printf(m, "%d\n", lookupCacheEnabled);
 973         return 0;
 974 }
 975
 976 static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
 977 {
 978         return single_open(file, cifs_lookup_cache_proc_show, NULL);
 979 }
 980
 981 static ssize_t cifs_lookup_cache_proc_write(struct file *file,
 982                 const char __user *buffer, size_t count, loff_t *ppos)
 983 {
 984         int rc;
 985
 986         rc = kstrtobool_from_user(buffer, count, &lookupCacheEnabled);
 987         if (rc)
 988                 return rc;
 989
 990         return count;
 991 }
 992
 993 static const struct proc_ops cifs_lookup_cache_proc_ops = {
 994         .proc_open      = cifs_lookup_cache_proc_open,
 995         .proc_read      = seq_read,
 996         .proc_lseek     = seq_lseek,
 997         .proc_release   = single_release,
 998         .proc_write     = cifs_lookup_cache_proc_write,
 999 };
1000
1001 static int traceSMB_proc_show(struct seq_file *m, void *v)
1002 {
1003         seq_printf(m, "%d\n", traceSMB);
1004         return 0;
1005 }
1006
1007 static int traceSMB_proc_open(struct inode *inode, struct file *file)
1008 {
1009         return single_open(file, traceSMB_proc_show, NULL);
1010 }
1011
1012 static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
1013                 size_t count, loff_t *ppos)
1014 {
1015         int rc;
1016
1017         rc = kstrtobool_from_user(buffer, count, &traceSMB);
1018         if (rc)
1019                 return rc;
1020
1021         return count;
1022 }
1023
1024 static const struct proc_ops traceSMB_proc_ops = {
1025         .proc_open      = traceSMB_proc_open,
1026         .proc_read      = seq_read,
1027         .proc_lseek     = seq_lseek,
1028         .proc_release   = single_release,
1029         .proc_write     = traceSMB_proc_write,
1030 };
1031
1032 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
1033 {
1034         seq_printf(m, "0x%x\n", global_secflags);
1035         return 0;
1036 }
1037
1038 static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
1039 {
1040         return single_open(file, cifs_security_flags_proc_show, NULL);
1041 }
1042
1043 /*
1044  * Ensure that if someone sets a MUST flag, that we disable all other MAY
1045  * flags except for the ones corresponding to the given MUST flag. If there are
1046  * multiple MUST flags, then try to prefer more secure ones.
1047  */
1048 static void
1049 cifs_security_flags_handle_must_flags(unsigned int *flags)
1050 {
1051         unsigned int signflags = *flags & CIFSSEC_MUST_SIGN;
1052
1053         if ((*flags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
1054                 *flags = CIFSSEC_MUST_KRB5;
1055         else if ((*flags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
1056                 *flags = CIFSSEC_MUST_NTLMSSP;
1057         else if ((*flags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
1058                 *flags = CIFSSEC_MUST_NTLMV2;
1059
1060         *flags |= signflags;
1061 }
1062
1063 static ssize_t cifs_security_flags_proc_write(struct file *file,
1064                 const char __user *buffer, size_t count, loff_t *ppos)
1065 {
1066         int rc;
1067         unsigned int flags;
1068         char flags_string[12];
1069         bool bv;
1070
1071         if ((count < 1) || (count > 11))
1072                 return -EINVAL;
1073
1074         memset(flags_string, 0, 12);
1075
1076         if (copy_from_user(flags_string, buffer, count))
1077                 return -EFAULT;
1078
1079         if (count < 3) {
1080                 /* single char or single char followed by null */
1081                 if (kstrtobool(flags_string, &bv) == 0) {
1082                         global_secflags = bv ? CIFSSEC_MAX : CIFSSEC_DEF;
1083                         return count;
1084                 } else if (!isdigit(flags_string[0])) {
1085                         cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
1086                                         flags_string);
1087                         return -EINVAL;
1088                 }
1089         }
1090
1091         /* else we have a number */
1092         rc = kstrtouint(flags_string, 0, &flags);
1093         if (rc) {
1094                 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n",
1095                                 flags_string);
1096                 return rc;
1097         }
1098
1099         cifs_dbg(FYI, "sec flags 0x%x\n", flags);
1100
1101         if (flags == 0)  {
1102                 cifs_dbg(VFS, "Invalid SecurityFlags: %s\n", flags_string);
1103                 return -EINVAL;
1104         }
1105
1106         if (flags & ~CIFSSEC_MASK) {
1107                 cifs_dbg(VFS, "Unsupported security flags: 0x%x\n",
1108                          flags & ~CIFSSEC_MASK);
1109                 return -EINVAL;
1110         }
1111
1112         cifs_security_flags_handle_must_flags(&flags);
1113
1114         /* flags look ok - update the global security flags for cifs module */
1115         global_secflags = flags;
1116         if (global_secflags & CIFSSEC_MUST_SIGN) {
1117                 /* requiring signing implies signing is allowed */
1118                 global_secflags |= CIFSSEC_MAY_SIGN;
1119                 cifs_dbg(FYI, "packet signing now required\n");
1120         } else if ((global_secflags & CIFSSEC_MAY_SIGN) == 0) {
1121                 cifs_dbg(FYI, "packet signing disabled\n");
1122         }
1123         /* BB should we turn on MAY flags for other MUST options? */
1124         return count;
1125 }
1126
1127 static const struct proc_ops cifs_security_flags_proc_ops = {
1128         .proc_open      = cifs_security_flags_proc_open,
1129         .proc_read      = seq_read,
1130         .proc_lseek     = seq_lseek,
1131         .proc_release   = single_release,
1132         .proc_write     = cifs_security_flags_proc_write,
1133 };
1134
1135 /* To make it easier to debug, can help to show mount params */
1136 static int cifs_mount_params_proc_show(struct seq_file *m, void *v)
1137 {
1138         const struct fs_parameter_spec *p;
1139         const char *type;
1140
1141         for (p = smb3_fs_parameters; p->name; p++) {
1142                 /* cannot use switch with pointers... */
1143                 if (!p->type) {
1144                         if (p->flags == fs_param_neg_with_no)
1145                                 type = "noflag";
1146                         else
1147                                 type = "flag";
1148                 } else if (p->type == fs_param_is_bool)
1149                         type = "bool";
1150                 else if (p->type == fs_param_is_u32)
1151                         type = "u32";
1152                 else if (p->type == fs_param_is_u64)
1153                         type = "u64";
1154                 else if (p->type == fs_param_is_string)
1155                         type = "string";
1156                 else
1157                         type = "unknown";
1158
1159                 seq_printf(m, "%s:%s\n", p->name, type);
1160         }
1161
1162         return 0;
1163 }
1164
1165 static int cifs_mount_params_proc_open(struct inode *inode, struct file *file)
1166 {
1167         return single_open(file, cifs_mount_params_proc_show, NULL);
1168 }
1169
1170 static const struct proc_ops cifs_mount_params_proc_ops = {
1171         .proc_open      = cifs_mount_params_proc_open,
1172         .proc_read      = seq_read,
1173         .proc_lseek     = seq_lseek,
1174         .proc_release   = single_release,
1175         /* No need for write for now */
1176         /* .proc_write  = cifs_mount_params_proc_write, */
1177 };
1178
1179 #else
1180 inline void cifs_proc_init(void)
1181 {
1182 }
1183
1184 inline void cifs_proc_clean(void)
1185 {
1186 }
1187 #endif /* PROC_FS */