1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
4 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
10 #include <linux/sched/signal.h>
11 #include <linux/workqueue.h>
12 #include <linux/sysfs.h>
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
17 #include "smb_common.h"
18 #include "smbstatus.h"
19 #include "connection.h"
20 #include "transport_ipc.h"
21 #include "mgmt/user_session.h"
22 #include "crypto_ctx.h"
25 int ksmbd_debug_types;
27 struct ksmbd_server_config server_conf;
29 enum SERVER_CTRL_TYPE {
30 SERVER_CTRL_TYPE_INIT,
31 SERVER_CTRL_TYPE_RESET,
34 struct server_ctrl_struct {
36 struct work_struct ctrl_work;
39 static DEFINE_MUTEX(ctrl_lock);
41 static int ___server_conf_set(int idx, char *val)
43 if (idx >= ARRAY_SIZE(server_conf.conf))
46 if (!val || val[0] == 0x00)
49 kfree(server_conf.conf[idx]);
50 server_conf.conf[idx] = kstrdup(val, GFP_KERNEL);
51 if (!server_conf.conf[idx])
56 int ksmbd_set_netbios_name(char *v)
58 return ___server_conf_set(SERVER_CONF_NETBIOS_NAME, v);
61 int ksmbd_set_server_string(char *v)
63 return ___server_conf_set(SERVER_CONF_SERVER_STRING, v);
66 int ksmbd_set_work_group(char *v)
68 return ___server_conf_set(SERVER_CONF_WORK_GROUP, v);
71 char *ksmbd_netbios_name(void)
73 return server_conf.conf[SERVER_CONF_NETBIOS_NAME];
76 char *ksmbd_server_string(void)
78 return server_conf.conf[SERVER_CONF_SERVER_STRING];
81 char *ksmbd_work_group(void)
83 return server_conf.conf[SERVER_CONF_WORK_GROUP];
87 * check_conn_state() - check state of server thread connection
88 * @work: smb work containing server thread information
90 * Return: 0 on valid connection, otherwise 1 to reconnect
92 static inline int check_conn_state(struct ksmbd_work *work)
94 struct smb_hdr *rsp_hdr;
96 if (ksmbd_conn_exiting(work->conn) ||
97 ksmbd_conn_need_reconnect(work->conn)) {
98 rsp_hdr = work->response_buf;
99 rsp_hdr->Status.CifsError = STATUS_CONNECTION_DISCONNECTED;
105 #define SERVER_HANDLER_CONTINUE 0
106 #define SERVER_HANDLER_ABORT 1
108 static int __process_request(struct ksmbd_work *work, struct ksmbd_conn *conn,
111 struct smb_version_cmds *cmds;
115 if (check_conn_state(work))
116 return SERVER_HANDLER_CONTINUE;
118 if (ksmbd_verify_smb_message(work))
119 return SERVER_HANDLER_ABORT;
121 command = conn->ops->get_cmd_val(work);
125 if (command >= conn->max_cmds) {
126 conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER);
127 return SERVER_HANDLER_CONTINUE;
130 cmds = &conn->cmds[command];
132 ksmbd_debug(SMB, "*** not implemented yet cmd = %x\n", command);
133 conn->ops->set_rsp_status(work, STATUS_NOT_IMPLEMENTED);
134 return SERVER_HANDLER_CONTINUE;
137 if (work->sess && conn->ops->is_sign_req(work, command)) {
138 ret = conn->ops->check_sign_req(work);
140 conn->ops->set_rsp_status(work, STATUS_ACCESS_DENIED);
141 return SERVER_HANDLER_CONTINUE;
145 ret = cmds->proc(work);
148 ksmbd_debug(CONN, "Failed to process %u [%d]\n", command, ret);
149 /* AndX commands - chained request can return positive values */
156 if (work->send_no_response)
157 return SERVER_HANDLER_ABORT;
158 return SERVER_HANDLER_CONTINUE;
161 static void __handle_ksmbd_work(struct ksmbd_work *work,
162 struct ksmbd_conn *conn)
167 if (conn->ops->allocate_rsp_buf(work))
170 if (conn->ops->is_transform_hdr &&
171 conn->ops->is_transform_hdr(work->request_buf)) {
172 rc = conn->ops->decrypt_req(work);
174 conn->ops->set_rsp_status(work, STATUS_DATA_ERROR);
178 work->encrypted = true;
181 rc = conn->ops->init_rsp_hdr(work);
183 /* either uid or tid is not correct */
184 conn->ops->set_rsp_status(work, STATUS_INVALID_HANDLE);
189 if (conn->ops->check_user_session) {
190 rc = conn->ops->check_user_session(work);
193 conn->ops->set_rsp_status(work,
194 STATUS_INVALID_PARAMETER);
196 conn->ops->set_rsp_status(work,
197 STATUS_USER_SESSION_DELETED);
200 rc = conn->ops->get_ksmbd_tcon(work);
203 conn->ops->set_rsp_status(work,
204 STATUS_INVALID_PARAMETER);
206 conn->ops->set_rsp_status(work,
207 STATUS_NETWORK_NAME_DELETED);
213 rc = __process_request(work, conn, &command);
214 if (rc == SERVER_HANDLER_ABORT)
218 * Call smb2_set_rsp_credits() function to set number of credits
219 * granted in hdr of smb2 response.
221 if (conn->ops->set_rsp_credits) {
222 spin_lock(&conn->credits_lock);
223 rc = conn->ops->set_rsp_credits(work);
224 spin_unlock(&conn->credits_lock);
226 conn->ops->set_rsp_status(work,
227 STATUS_INVALID_PARAMETER);
233 (work->sess->sign || smb3_11_final_sess_setup_resp(work) ||
234 conn->ops->is_sign_req(work, command)))
235 conn->ops->set_sign_rsp(work);
236 } while (is_chained_smb2_message(work));
238 if (work->send_no_response)
242 smb3_preauth_hash_rsp(work);
243 if (work->sess && work->sess->enc && work->encrypted &&
244 conn->ops->encrypt_resp) {
245 rc = conn->ops->encrypt_resp(work);
247 conn->ops->set_rsp_status(work, STATUS_DATA_ERROR);
250 ksmbd_conn_write(work);
254 * handle_ksmbd_work() - process pending smb work requests
255 * @wk: smb work containing request command buffer
257 * called by kworker threads to processing remaining smb work requests
259 static void handle_ksmbd_work(struct work_struct *wk)
261 struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work);
262 struct ksmbd_conn *conn = work->conn;
264 atomic64_inc(&conn->stats.request_served);
266 __handle_ksmbd_work(work, conn);
268 ksmbd_conn_try_dequeue_request(work);
269 ksmbd_free_work_struct(work);
271 * Checking waitqueue to dropping pending requests on
272 * disconnection. waitqueue_active is safe because it
273 * uses atomic operation for condition.
275 if (!atomic_dec_return(&conn->r_count) && waitqueue_active(&conn->r_count_q))
276 wake_up(&conn->r_count_q);
280 * queue_ksmbd_work() - queue a smb request to worker thread queue
281 * for proccessing smb command and sending response
282 * @conn: connection instance
284 * read remaining data from socket create and submit work.
286 static int queue_ksmbd_work(struct ksmbd_conn *conn)
288 struct ksmbd_work *work;
291 work = ksmbd_alloc_work_struct();
293 pr_err("allocation for work failed\n");
298 work->request_buf = conn->request_buf;
299 conn->request_buf = NULL;
301 err = ksmbd_init_smb_server(work);
303 ksmbd_free_work_struct(work);
307 ksmbd_conn_enqueue_request(work);
308 atomic_inc(&conn->r_count);
309 /* update activity on connection */
310 conn->last_active = jiffies;
311 INIT_WORK(&work->work, handle_ksmbd_work);
312 ksmbd_queue_work(work);
316 static int ksmbd_server_process_request(struct ksmbd_conn *conn)
318 return queue_ksmbd_work(conn);
321 static int ksmbd_server_terminate_conn(struct ksmbd_conn *conn)
323 ksmbd_sessions_deregister(conn);
324 destroy_lease_table(conn);
328 static void ksmbd_server_tcp_callbacks_init(void)
330 struct ksmbd_conn_ops ops;
332 ops.process_fn = ksmbd_server_process_request;
333 ops.terminate_fn = ksmbd_server_terminate_conn;
335 ksmbd_conn_init_server_callbacks(&ops);
338 static void server_conf_free(void)
342 for (i = 0; i < ARRAY_SIZE(server_conf.conf); i++) {
343 kfree(server_conf.conf[i]);
344 server_conf.conf[i] = NULL;
348 static int server_conf_init(void)
350 WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP);
351 server_conf.enforced_signing = 0;
352 server_conf.min_protocol = ksmbd_min_protocol();
353 server_conf.max_protocol = ksmbd_max_protocol();
354 server_conf.auth_mechs = KSMBD_AUTH_NTLMSSP;
355 #ifdef CONFIG_SMB_SERVER_KERBEROS5
356 server_conf.auth_mechs |= KSMBD_AUTH_KRB5 |
362 static void server_ctrl_handle_init(struct server_ctrl_struct *ctrl)
366 ret = ksmbd_conn_transport_init();
368 server_queue_ctrl_reset_work();
372 WRITE_ONCE(server_conf.state, SERVER_STATE_RUNNING);
375 static void server_ctrl_handle_reset(struct server_ctrl_struct *ctrl)
377 ksmbd_ipc_soft_reset();
378 ksmbd_conn_transport_destroy();
381 WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP);
384 static void server_ctrl_handle_work(struct work_struct *work)
386 struct server_ctrl_struct *ctrl;
388 ctrl = container_of(work, struct server_ctrl_struct, ctrl_work);
390 mutex_lock(&ctrl_lock);
391 switch (ctrl->type) {
392 case SERVER_CTRL_TYPE_INIT:
393 server_ctrl_handle_init(ctrl);
395 case SERVER_CTRL_TYPE_RESET:
396 server_ctrl_handle_reset(ctrl);
399 pr_err("Unknown server work type: %d\n", ctrl->type);
401 mutex_unlock(&ctrl_lock);
403 module_put(THIS_MODULE);
406 static int __queue_ctrl_work(int type)
408 struct server_ctrl_struct *ctrl;
410 ctrl = kmalloc(sizeof(struct server_ctrl_struct), GFP_KERNEL);
414 __module_get(THIS_MODULE);
416 INIT_WORK(&ctrl->ctrl_work, server_ctrl_handle_work);
417 queue_work(system_long_wq, &ctrl->ctrl_work);
421 int server_queue_ctrl_init_work(void)
423 return __queue_ctrl_work(SERVER_CTRL_TYPE_INIT);
426 int server_queue_ctrl_reset_work(void)
428 return __queue_ctrl_work(SERVER_CTRL_TYPE_RESET);
431 static ssize_t stats_show(const struct class *class, const struct class_attribute *attr,
435 * Inc this each time you change stats output format,
436 * so user space will know what to do.
438 static int stats_version = 2;
439 static const char * const state[] = {
445 return sysfs_emit(buf, "%d %s %d %lu\n", stats_version,
446 state[server_conf.state], server_conf.tcp_port,
447 server_conf.ipc_last_active / HZ);
450 static ssize_t kill_server_store(const struct class *class,
451 const struct class_attribute *attr, const char *buf,
454 if (!sysfs_streq(buf, "hard"))
457 pr_info("kill command received\n");
458 mutex_lock(&ctrl_lock);
459 WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
460 __module_get(THIS_MODULE);
461 server_ctrl_handle_reset(NULL);
462 module_put(THIS_MODULE);
463 mutex_unlock(&ctrl_lock);
467 static const char * const debug_type_strings[] = {"smb", "auth", "vfs",
468 "oplock", "ipc", "conn",
471 static ssize_t debug_show(const struct class *class, const struct class_attribute *attr,
477 for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) {
478 if ((ksmbd_debug_types >> i) & 1) {
479 pos = sysfs_emit_at(buf, sz, "[%s] ", debug_type_strings[i]);
481 pos = sysfs_emit_at(buf, sz, "%s ", debug_type_strings[i]);
485 sz += sysfs_emit_at(buf, sz, "\n");
489 static ssize_t debug_store(const struct class *class, const struct class_attribute *attr,
490 const char *buf, size_t len)
494 for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) {
495 if (sysfs_streq(buf, "all")) {
496 if (ksmbd_debug_types == KSMBD_DEBUG_ALL)
497 ksmbd_debug_types = 0;
499 ksmbd_debug_types = KSMBD_DEBUG_ALL;
503 if (sysfs_streq(buf, debug_type_strings[i])) {
504 if (ksmbd_debug_types & (1 << i))
505 ksmbd_debug_types &= ~(1 << i);
507 ksmbd_debug_types |= (1 << i);
515 static CLASS_ATTR_RO(stats);
516 static CLASS_ATTR_WO(kill_server);
517 static CLASS_ATTR_RW(debug);
519 static struct attribute *ksmbd_control_class_attrs[] = {
520 &class_attr_stats.attr,
521 &class_attr_kill_server.attr,
522 &class_attr_debug.attr,
525 ATTRIBUTE_GROUPS(ksmbd_control_class);
527 static struct class ksmbd_control_class = {
528 .name = "ksmbd-control",
529 .class_groups = ksmbd_control_class_groups,
532 static int ksmbd_server_shutdown(void)
534 WRITE_ONCE(server_conf.state, SERVER_STATE_SHUTTING_DOWN);
536 class_unregister(&ksmbd_control_class);
537 ksmbd_workqueue_destroy();
539 ksmbd_conn_transport_destroy();
540 ksmbd_crypto_destroy();
541 ksmbd_free_global_file_table();
542 destroy_lease_table(NULL);
543 ksmbd_work_pool_destroy();
544 ksmbd_exit_file_cache();
549 static int __init ksmbd_server_init(void)
553 ret = class_register(&ksmbd_control_class);
555 pr_err("Unable to register ksmbd-control class\n");
559 ksmbd_server_tcp_callbacks_init();
561 ret = server_conf_init();
565 ret = ksmbd_work_pool_init();
569 ret = ksmbd_init_file_cache();
571 goto err_destroy_work_pools;
573 ret = ksmbd_ipc_init();
575 goto err_exit_file_cache;
577 ret = ksmbd_init_global_file_table();
579 goto err_ipc_release;
581 ret = ksmbd_inode_hash_init();
583 goto err_destroy_file_table;
585 ret = ksmbd_crypto_create();
587 goto err_release_inode_hash;
589 ret = ksmbd_workqueue_init();
591 goto err_crypto_destroy;
593 pr_warn_once("The ksmbd server is experimental\n");
598 ksmbd_crypto_destroy();
599 err_release_inode_hash:
600 ksmbd_release_inode_hash();
601 err_destroy_file_table:
602 ksmbd_free_global_file_table();
606 ksmbd_exit_file_cache();
607 err_destroy_work_pools:
608 ksmbd_work_pool_destroy();
610 class_unregister(&ksmbd_control_class);
616 * ksmbd_server_exit() - shutdown forker thread and free memory at module exit
618 static void __exit ksmbd_server_exit(void)
620 ksmbd_server_shutdown();
622 ksmbd_release_inode_hash();
625 MODULE_AUTHOR("Namjae Jeon <linkinjeon@kernel.org>");
626 MODULE_VERSION(KSMBD_VERSION);
627 MODULE_DESCRIPTION("Linux kernel CIFS/SMB SERVER");
628 MODULE_LICENSE("GPL");
629 MODULE_SOFTDEP("pre: ecb");
630 MODULE_SOFTDEP("pre: hmac");
631 MODULE_SOFTDEP("pre: md5");
632 MODULE_SOFTDEP("pre: nls");
633 MODULE_SOFTDEP("pre: aes");
634 MODULE_SOFTDEP("pre: cmac");
635 MODULE_SOFTDEP("pre: sha256");
636 MODULE_SOFTDEP("pre: sha512");
637 MODULE_SOFTDEP("pre: aead2");
638 MODULE_SOFTDEP("pre: ccm");
639 MODULE_SOFTDEP("pre: gcm");
640 MODULE_SOFTDEP("pre: crc32");
641 module_init(ksmbd_server_init)
642 module_exit(ksmbd_server_exit)