1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2016 Namjae Jeon <namjae.jeon@protocolfreedom.org>
4 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
7 #include <linux/mutex.h>
8 #include <linux/freezer.h>
9 #include <linux/module.h>
12 #include "smb_common.h"
13 #include "mgmt/ksmbd_ida.h"
14 #include "connection.h"
15 #include "transport_tcp.h"
16 #include "transport_rdma.h"
18 static DEFINE_MUTEX(init_lock
);
20 static struct ksmbd_conn_ops default_conn_ops
;
23 DEFINE_RWLOCK(conn_list_lock
);
26 * ksmbd_conn_free() - free resources of the connection instance
28 * @conn: connection instance to be cleand up
30 * During the thread termination, the corresponding conn instance
31 * resources(sock/memory) are released and finally the conn object is freed.
33 void ksmbd_conn_free(struct ksmbd_conn
*conn
)
35 write_lock(&conn_list_lock
);
36 list_del(&conn
->conns_list
);
37 write_unlock(&conn_list_lock
);
39 kvfree(conn
->request_buf
);
40 kfree(conn
->preauth_info
);
45 * ksmbd_conn_alloc() - initialize a new connection instance
47 * Return: ksmbd_conn struct on success, otherwise NULL
49 struct ksmbd_conn
*ksmbd_conn_alloc(void)
51 struct ksmbd_conn
*conn
;
53 conn
= kzalloc(sizeof(struct ksmbd_conn
), GFP_KERNEL
);
57 conn
->need_neg
= true;
58 conn
->status
= KSMBD_SESS_NEW
;
59 conn
->local_nls
= load_nls("utf8");
61 conn
->local_nls
= load_nls_default();
62 atomic_set(&conn
->req_running
, 0);
63 atomic_set(&conn
->r_count
, 0);
64 init_waitqueue_head(&conn
->req_running_q
);
65 INIT_LIST_HEAD(&conn
->conns_list
);
66 INIT_LIST_HEAD(&conn
->sessions
);
67 INIT_LIST_HEAD(&conn
->requests
);
68 INIT_LIST_HEAD(&conn
->async_requests
);
69 spin_lock_init(&conn
->request_lock
);
70 spin_lock_init(&conn
->credits_lock
);
71 ida_init(&conn
->async_ida
);
73 spin_lock_init(&conn
->llist_lock
);
74 INIT_LIST_HEAD(&conn
->lock_list
);
76 write_lock(&conn_list_lock
);
77 list_add(&conn
->conns_list
, &conn_list
);
78 write_unlock(&conn_list_lock
);
82 bool ksmbd_conn_lookup_dialect(struct ksmbd_conn
*c
)
87 read_lock(&conn_list_lock
);
88 list_for_each_entry(t
, &conn_list
, conns_list
) {
89 if (memcmp(t
->ClientGUID
, c
->ClientGUID
, SMB2_CLIENT_GUID_SIZE
))
95 read_unlock(&conn_list_lock
);
99 void ksmbd_conn_enqueue_request(struct ksmbd_work
*work
)
101 struct ksmbd_conn
*conn
= work
->conn
;
102 struct list_head
*requests_queue
= NULL
;
104 if (conn
->ops
->get_cmd_val(work
) != SMB2_CANCEL_HE
) {
105 requests_queue
= &conn
->requests
;
106 work
->syncronous
= true;
109 if (requests_queue
) {
110 atomic_inc(&conn
->req_running
);
111 spin_lock(&conn
->request_lock
);
112 list_add_tail(&work
->request_entry
, requests_queue
);
113 spin_unlock(&conn
->request_lock
);
117 int ksmbd_conn_try_dequeue_request(struct ksmbd_work
*work
)
119 struct ksmbd_conn
*conn
= work
->conn
;
122 if (list_empty(&work
->request_entry
) &&
123 list_empty(&work
->async_request_entry
))
127 atomic_dec(&conn
->req_running
);
128 spin_lock(&conn
->request_lock
);
129 if (!work
->multiRsp
) {
130 list_del_init(&work
->request_entry
);
131 if (work
->syncronous
== false)
132 list_del_init(&work
->async_request_entry
);
135 spin_unlock(&conn
->request_lock
);
137 wake_up_all(&conn
->req_running_q
);
141 static void ksmbd_conn_lock(struct ksmbd_conn
*conn
)
143 mutex_lock(&conn
->srv_mutex
);
146 static void ksmbd_conn_unlock(struct ksmbd_conn
*conn
)
148 mutex_unlock(&conn
->srv_mutex
);
151 void ksmbd_conn_wait_idle(struct ksmbd_conn
*conn
)
153 wait_event(conn
->req_running_q
, atomic_read(&conn
->req_running
) < 2);
156 int ksmbd_conn_write(struct ksmbd_work
*work
)
158 struct ksmbd_conn
*conn
= work
->conn
;
159 struct smb_hdr
*rsp_hdr
= work
->response_buf
;
165 ksmbd_conn_try_dequeue_request(work
);
167 pr_err("NULL response header\n");
172 iov
[iov_idx
] = (struct kvec
) { work
->tr_buf
,
173 sizeof(struct smb2_transform_hdr
) };
174 len
+= iov
[iov_idx
++].iov_len
;
177 if (work
->aux_payload_sz
) {
178 iov
[iov_idx
] = (struct kvec
) { rsp_hdr
, work
->resp_hdr_sz
};
179 len
+= iov
[iov_idx
++].iov_len
;
180 iov
[iov_idx
] = (struct kvec
) { work
->aux_payload_buf
, work
->aux_payload_sz
};
181 len
+= iov
[iov_idx
++].iov_len
;
184 iov
[iov_idx
].iov_len
= work
->resp_hdr_sz
;
186 iov
[iov_idx
].iov_len
= get_rfc1002_len(rsp_hdr
) + 4;
187 iov
[iov_idx
].iov_base
= rsp_hdr
;
188 len
+= iov
[iov_idx
++].iov_len
;
191 ksmbd_conn_lock(conn
);
192 sent
= conn
->transport
->ops
->writev(conn
->transport
, &iov
[0],
194 work
->need_invalidate_rkey
,
196 ksmbd_conn_unlock(conn
);
199 pr_err("Failed to send message: %d\n", sent
);
206 int ksmbd_conn_rdma_read(struct ksmbd_conn
*conn
, void *buf
,
207 unsigned int buflen
, u32 remote_key
, u64 remote_offset
,
212 if (conn
->transport
->ops
->rdma_read
)
213 ret
= conn
->transport
->ops
->rdma_read(conn
->transport
,
215 remote_key
, remote_offset
,
220 int ksmbd_conn_rdma_write(struct ksmbd_conn
*conn
, void *buf
,
221 unsigned int buflen
, u32 remote_key
,
222 u64 remote_offset
, u32 remote_len
)
226 if (conn
->transport
->ops
->rdma_write
)
227 ret
= conn
->transport
->ops
->rdma_write(conn
->transport
,
229 remote_key
, remote_offset
,
234 bool ksmbd_conn_alive(struct ksmbd_conn
*conn
)
236 if (!ksmbd_server_running())
239 if (conn
->status
== KSMBD_SESS_EXITING
)
242 if (kthread_should_stop())
245 if (atomic_read(&conn
->stats
.open_files_count
) > 0)
249 * Stop current session if the time that get last request from client
250 * is bigger than deadtime user configured and opening file count is
253 if (server_conf
.deadtime
> 0 &&
254 time_after(jiffies
, conn
->last_active
+ server_conf
.deadtime
)) {
255 ksmbd_debug(CONN
, "No response from client in %lu minutes\n",
256 server_conf
.deadtime
/ SMB_ECHO_INTERVAL
);
263 * ksmbd_conn_handler_loop() - session thread to listen on new smb requests
264 * @p: connection instance
266 * One thread each per connection
268 * Return: 0 on success
270 int ksmbd_conn_handler_loop(void *p
)
272 struct ksmbd_conn
*conn
= (struct ksmbd_conn
*)p
;
273 struct ksmbd_transport
*t
= conn
->transport
;
274 unsigned int pdu_size
;
275 char hdr_buf
[4] = {0,};
278 mutex_init(&conn
->srv_mutex
);
279 __module_get(THIS_MODULE
);
281 if (t
->ops
->prepare
&& t
->ops
->prepare(t
))
284 conn
->last_active
= jiffies
;
285 while (ksmbd_conn_alive(conn
)) {
289 kvfree(conn
->request_buf
);
290 conn
->request_buf
= NULL
;
292 size
= t
->ops
->read(t
, hdr_buf
, sizeof(hdr_buf
));
293 if (size
!= sizeof(hdr_buf
))
296 pdu_size
= get_rfc1002_len(hdr_buf
);
297 ksmbd_debug(CONN
, "RFC1002 header %u bytes\n", pdu_size
);
300 * Check if pdu size is valid (min : smb header size,
303 if (pdu_size
< __SMB2_HEADER_STRUCTURE_SIZE
||
304 pdu_size
> MAX_STREAM_PROT_LEN
) {
308 /* 4 for rfc1002 length field */
310 conn
->request_buf
= kvmalloc(size
, GFP_KERNEL
);
311 if (!conn
->request_buf
)
314 memcpy(conn
->request_buf
, hdr_buf
, sizeof(hdr_buf
));
315 if (!ksmbd_smb_request(conn
))
319 * We already read 4 bytes to find out PDU size, now
322 size
= t
->ops
->read(t
, conn
->request_buf
+ 4, pdu_size
);
324 pr_err("sock_read failed: %d\n", size
);
328 if (size
!= pdu_size
) {
329 pr_err("PDU error. Read: %d, Expected: %d\n",
334 if (!default_conn_ops
.process_fn
) {
335 pr_err("No connection request callback\n");
339 if (default_conn_ops
.process_fn(conn
)) {
340 pr_err("Cannot handle request\n");
346 /* Wait till all reference dropped to the Server object*/
347 while (atomic_read(&conn
->r_count
) > 0)
348 schedule_timeout(HZ
);
350 unload_nls(conn
->local_nls
);
351 if (default_conn_ops
.terminate_fn
)
352 default_conn_ops
.terminate_fn(conn
);
353 t
->ops
->disconnect(t
);
354 module_put(THIS_MODULE
);
358 void ksmbd_conn_init_server_callbacks(struct ksmbd_conn_ops
*ops
)
360 default_conn_ops
.process_fn
= ops
->process_fn
;
361 default_conn_ops
.terminate_fn
= ops
->terminate_fn
;
364 int ksmbd_conn_transport_init(void)
368 mutex_lock(&init_lock
);
369 ret
= ksmbd_tcp_init();
371 pr_err("Failed to init TCP subsystem: %d\n", ret
);
375 ret
= ksmbd_rdma_init();
377 pr_err("Failed to init RDMA subsystem: %d\n", ret
);
381 mutex_unlock(&init_lock
);
385 static void stop_sessions(void)
387 struct ksmbd_conn
*conn
;
390 read_lock(&conn_list_lock
);
391 list_for_each_entry(conn
, &conn_list
, conns_list
) {
392 struct task_struct
*task
;
394 task
= conn
->transport
->handler
;
396 ksmbd_debug(CONN
, "Stop session handler %s/%d\n",
397 task
->comm
, task_pid_nr(task
));
398 conn
->status
= KSMBD_SESS_EXITING
;
400 read_unlock(&conn_list_lock
);
402 if (!list_empty(&conn_list
)) {
403 schedule_timeout_interruptible(HZ
/ 10); /* 100ms */
408 void ksmbd_conn_transport_destroy(void)
410 mutex_lock(&init_lock
);
412 ksmbd_rdma_destroy();
414 mutex_unlock(&init_lock
);