fs/ksmbd/connection.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
   4  */
   5
   6 #ifndef __KSMBD_CONNECTION_H__
   7 #define __KSMBD_CONNECTION_H__
   8
   9 #include <linux/list.h>
  10 #include <linux/ip.h>
  11 #include <net/sock.h>
  12 #include <net/tcp.h>
  13 #include <net/inet_connection_sock.h>
  14 #include <net/request_sock.h>
  15 #include <linux/kthread.h>
  16 #include <linux/nls.h>
  17 #include <linux/unicode.h>
  18
  19 #include "smb_common.h"
  20 #include "ksmbd_work.h"
  21
  22 #define KSMBD_SOCKET_BACKLOG            16
  23
  24 enum {
  25         KSMBD_SESS_NEW = 0,
  26         KSMBD_SESS_GOOD,
  27         KSMBD_SESS_EXITING,
  28         KSMBD_SESS_NEED_RECONNECT,
  29         KSMBD_SESS_NEED_NEGOTIATE,
  30         KSMBD_SESS_RELEASING
  31 };
  32
  33 struct ksmbd_stats {
  34         atomic_t                        open_files_count;
  35         atomic64_t                      request_served;
  36 };
  37
  38 struct ksmbd_transport;
  39
  40 struct ksmbd_conn {
  41         struct smb_version_values       *vals;
  42         struct smb_version_ops          *ops;
  43         struct smb_version_cmds         *cmds;
  44         unsigned int                    max_cmds;
  45         struct mutex                    srv_mutex;
  46         int                             status;
  47         unsigned int                    cli_cap;
  48         char                            *request_buf;
  49         struct ksmbd_transport          *transport;
  50         struct nls_table                *local_nls;
  51         struct unicode_map              *um;
  52         struct list_head                conns_list;
  53         /* smb session 1 per user */
  54         struct xarray                   sessions;
  55         unsigned long                   last_active;
  56         /* How many request are running currently */
  57         atomic_t                        req_running;
  58         /* References which are made for this Server object*/
  59         atomic_t                        r_count;
  60         unsigned int                    total_credits;
  61         unsigned int                    outstanding_credits;
  62         spinlock_t                      credits_lock;
  63         wait_queue_head_t               req_running_q;
  64         wait_queue_head_t               r_count_q;
  65         /* Lock to protect requests list*/
  66         spinlock_t                      request_lock;
  67         struct list_head                requests;
  68         struct list_head                async_requests;
  69         int                             connection_type;
  70         struct ksmbd_stats              stats;
  71         char                            ClientGUID[SMB2_CLIENT_GUID_SIZE];
  72         struct ntlmssp_auth             ntlmssp;
  73
  74         spinlock_t                      llist_lock;
  75         struct list_head                lock_list;
  76
  77         struct preauth_integrity_info   *preauth_info;
  78
  79         bool                            need_neg;
  80         unsigned int                    auth_mechs;
  81         unsigned int                    preferred_auth_mech;
  82         bool                            sign;
  83         bool                            use_spnego:1;
  84         __u16                           cli_sec_mode;
  85         __u16                           srv_sec_mode;
  86         /* dialect index that server chose */
  87         __u16                           dialect;
  88
  89         char                            *mechToken;
  90
  91         struct ksmbd_conn_ops   *conn_ops;
  92
  93         /* Preauth Session Table */
  94         struct list_head                preauth_sess_table;
  95
  96         struct sockaddr_storage         peer_addr;
  97
  98         /* Identifier for async message */
  99         struct ida                      async_ida;
 100
 101         __le16                          cipher_type;
 102         __le16                          compress_algorithm;
 103         bool                            posix_ext_supported;
 104         bool                            signing_negotiated;
 105         __le16                          signing_algorithm;
 106         bool                            binding;
 107 };
 108
 109 struct ksmbd_conn_ops {
 110         int     (*process_fn)(struct ksmbd_conn *conn);
 111         int     (*terminate_fn)(struct ksmbd_conn *conn);
 112 };
 113
 114 struct ksmbd_transport_ops {
 115         int (*prepare)(struct ksmbd_transport *t);
 116         void (*disconnect)(struct ksmbd_transport *t);
 117         void (*shutdown)(struct ksmbd_transport *t);
 118         int (*read)(struct ksmbd_transport *t, char *buf,
 119                     unsigned int size, int max_retries);
 120         int (*writev)(struct ksmbd_transport *t, struct kvec *iovs, int niov,
 121                       int size, bool need_invalidate_rkey,
 122                       unsigned int remote_key);
 123         int (*rdma_read)(struct ksmbd_transport *t,
 124                          void *buf, unsigned int len,
 125                          struct smb2_buffer_desc_v1 *desc,
 126                          unsigned int desc_len);
 127         int (*rdma_write)(struct ksmbd_transport *t,
 128                           void *buf, unsigned int len,
 129                           struct smb2_buffer_desc_v1 *desc,
 130                           unsigned int desc_len);
 131 };
 132
 133 struct ksmbd_transport {
 134         struct ksmbd_conn               *conn;
 135         struct ksmbd_transport_ops      *ops;
 136         struct task_struct              *handler;
 137 };
 138
 139 #define KSMBD_TCP_RECV_TIMEOUT  (7 * HZ)
 140 #define KSMBD_TCP_SEND_TIMEOUT  (5 * HZ)
 141 #define KSMBD_TCP_PEER_SOCKADDR(c)      ((struct sockaddr *)&((c)->peer_addr))
 142
 143 extern struct list_head conn_list;
 144 extern struct rw_semaphore conn_list_lock;
 145
 146 bool ksmbd_conn_alive(struct ksmbd_conn *conn);
 147 void ksmbd_conn_wait_idle(struct ksmbd_conn *conn, u64 sess_id);
 148 struct ksmbd_conn *ksmbd_conn_alloc(void);
 149 void ksmbd_conn_free(struct ksmbd_conn *conn);
 150 bool ksmbd_conn_lookup_dialect(struct ksmbd_conn *c);
 151 int ksmbd_conn_write(struct ksmbd_work *work);
 152 int ksmbd_conn_rdma_read(struct ksmbd_conn *conn,
 153                          void *buf, unsigned int buflen,
 154                          struct smb2_buffer_desc_v1 *desc,
 155                          unsigned int desc_len);
 156 int ksmbd_conn_rdma_write(struct ksmbd_conn *conn,
 157                           void *buf, unsigned int buflen,
 158                           struct smb2_buffer_desc_v1 *desc,
 159                           unsigned int desc_len);
 160 void ksmbd_conn_enqueue_request(struct ksmbd_work *work);
 161 int ksmbd_conn_try_dequeue_request(struct ksmbd_work *work);
 162 void ksmbd_conn_init_server_callbacks(struct ksmbd_conn_ops *ops);
 163 int ksmbd_conn_handler_loop(void *p);
 164 int ksmbd_conn_transport_init(void);
 165 void ksmbd_conn_transport_destroy(void);
 166 void ksmbd_conn_lock(struct ksmbd_conn *conn);
 167 void ksmbd_conn_unlock(struct ksmbd_conn *conn);
 168
 169 /*
 170  * WARNING
 171  *
 172  * This is a hack. We will move status to a proper place once we land
 173  * a multi-sessions support.
 174  */
 175 static inline bool ksmbd_conn_good(struct ksmbd_conn *conn)
 176 {
 177         return READ_ONCE(conn->status) == KSMBD_SESS_GOOD;
 178 }
 179
 180 static inline bool ksmbd_conn_need_negotiate(struct ksmbd_conn *conn)
 181 {
 182         return READ_ONCE(conn->status) == KSMBD_SESS_NEED_NEGOTIATE;
 183 }
 184
 185 static inline bool ksmbd_conn_need_reconnect(struct ksmbd_conn *conn)
 186 {
 187         return READ_ONCE(conn->status) == KSMBD_SESS_NEED_RECONNECT;
 188 }
 189
 190 static inline bool ksmbd_conn_exiting(struct ksmbd_conn *conn)
 191 {
 192         return READ_ONCE(conn->status) == KSMBD_SESS_EXITING;
 193 }
 194
 195 static inline bool ksmbd_conn_releasing(struct ksmbd_conn *conn)
 196 {
 197         return READ_ONCE(conn->status) == KSMBD_SESS_RELEASING;
 198 }
 199
 200 static inline void ksmbd_conn_set_new(struct ksmbd_conn *conn)
 201 {
 202         WRITE_ONCE(conn->status, KSMBD_SESS_NEW);
 203 }
 204
 205 static inline void ksmbd_conn_set_good(struct ksmbd_conn *conn)
 206 {
 207         WRITE_ONCE(conn->status, KSMBD_SESS_GOOD);
 208 }
 209
 210 static inline void ksmbd_conn_set_need_negotiate(struct ksmbd_conn *conn)
 211 {
 212         WRITE_ONCE(conn->status, KSMBD_SESS_NEED_NEGOTIATE);
 213 }
 214
 215 static inline void ksmbd_conn_set_need_reconnect(struct ksmbd_conn *conn)
 216 {
 217         WRITE_ONCE(conn->status, KSMBD_SESS_NEED_RECONNECT);
 218 }
 219
 220 static inline void ksmbd_conn_set_exiting(struct ksmbd_conn *conn)
 221 {
 222         WRITE_ONCE(conn->status, KSMBD_SESS_EXITING);
 223 }
 224
 225 static inline void ksmbd_conn_set_releasing(struct ksmbd_conn *conn)
 226 {
 227         WRITE_ONCE(conn->status, KSMBD_SESS_RELEASING);
 228 }
 229
 230 void ksmbd_all_conn_set_status(u64 sess_id, u32 status);
 231 #endif /* __CONNECTION_H__ */