server.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *   Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
  4 *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
  5 */
  6
  7#include "glob.h"
  8#include "oplock.h"
  9#include "misc.h"
 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>
 15
 16#include "server.h"
 17#include "smb_common.h"
 18#include "../common/smb2status.h"
 19#include "connection.h"
 20#include "transport_ipc.h"
 21#include "mgmt/user_session.h"
 22#include "crypto_ctx.h"
 23#include "auth.h"
 24
 25int ksmbd_debug_types;
 26
 27struct ksmbd_server_config server_conf;
 28
 29enum SERVER_CTRL_TYPE {
 30	SERVER_CTRL_TYPE_INIT,
 31	SERVER_CTRL_TYPE_RESET,
 32};
 33
 34struct server_ctrl_struct {
 35	int			type;
 36	struct work_struct	ctrl_work;
 37};
 38
 39static DEFINE_MUTEX(ctrl_lock);
 40
 41static int ___server_conf_set(int idx, char *val)
 42{
 43	if (idx >= ARRAY_SIZE(server_conf.conf))
 44		return -EINVAL;
 45
 46	if (!val || val[0] == 0x00)
 47		return -EINVAL;
 48
 49	kfree(server_conf.conf[idx]);
 50	server_conf.conf[idx] = kstrdup(val, KSMBD_DEFAULT_GFP);
 51	if (!server_conf.conf[idx])
 52		return -ENOMEM;
 53	return 0;
 54}
 55
 56int ksmbd_set_netbios_name(char *v)
 57{
 58	return ___server_conf_set(SERVER_CONF_NETBIOS_NAME, v);
 59}
 60
 61int ksmbd_set_server_string(char *v)
 62{
 63	return ___server_conf_set(SERVER_CONF_SERVER_STRING, v);
 64}
 65
 66int ksmbd_set_work_group(char *v)
 67{
 68	return ___server_conf_set(SERVER_CONF_WORK_GROUP, v);
 69}
 70
 71char *ksmbd_netbios_name(void)
 72{
 73	return server_conf.conf[SERVER_CONF_NETBIOS_NAME];
 74}
 75
 76char *ksmbd_server_string(void)
 77{
 78	return server_conf.conf[SERVER_CONF_SERVER_STRING];
 79}
 80
 81char *ksmbd_work_group(void)
 82{
 83	return server_conf.conf[SERVER_CONF_WORK_GROUP];
 84}
 85
 86/**
 87 * check_conn_state() - check state of server thread connection
 88 * @work:     smb work containing server thread information
 89 *
 90 * Return:	0 on valid connection, otherwise 1 to reconnect
 91 */
 92static inline int check_conn_state(struct ksmbd_work *work)
 93{
 94	struct smb_hdr *rsp_hdr;
 95
 96	if (ksmbd_conn_exiting(work->conn) ||
 97	    ksmbd_conn_need_reconnect(work->conn)) {
 98		rsp_hdr = smb_get_msg(work->response_buf);
 99		rsp_hdr->Status.CifsError = STATUS_CONNECTION_DISCONNECTED;
100		return 1;
101	}
102	return 0;
103}
104
105#define SERVER_HANDLER_CONTINUE		0
106#define SERVER_HANDLER_ABORT		1
107
108static int __process_request(struct ksmbd_work *work, struct ksmbd_conn *conn,
109			     u16 *cmd)
110{
111	struct smb_version_cmds *cmds;
112	u16 command;
113	int ret;
114
115	if (check_conn_state(work))
116		return SERVER_HANDLER_CONTINUE;
117
118	if (ksmbd_verify_smb_message(work)) {
119		conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER);
120		return SERVER_HANDLER_ABORT;
121	}
122
123	command = conn->ops->get_cmd_val(work);
124	*cmd = command;
125
126andx_again:
127	if (command >= conn->max_cmds) {
128		conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER);
129		return SERVER_HANDLER_ABORT;
130	}
131
132	cmds = &conn->cmds[command];
133	if (!cmds->proc) {
134		ksmbd_debug(SMB, "*** not implemented yet cmd = %x\n", command);
135		conn->ops->set_rsp_status(work, STATUS_NOT_IMPLEMENTED);
136		return SERVER_HANDLER_ABORT;
137	}
138
139	if (work->sess && conn->ops->is_sign_req(work, command)) {
140		ret = conn->ops->check_sign_req(work);
141		if (!ret) {
142			conn->ops->set_rsp_status(work, STATUS_ACCESS_DENIED);
143			return SERVER_HANDLER_ABORT;
144		}
145	}
146
147	ret = cmds->proc(work);
148
149	if (ret < 0)
150		ksmbd_debug(CONN, "Failed to process %u [%d]\n", command, ret);
151	/* AndX commands - chained request can return positive values */
152	else if (ret > 0) {
153		command = ret;
154		*cmd = command;
155		goto andx_again;
156	}
157
158	if (work->send_no_response)
159		return SERVER_HANDLER_ABORT;
160	return SERVER_HANDLER_CONTINUE;
161}
162
163static void __handle_ksmbd_work(struct ksmbd_work *work,
164				struct ksmbd_conn *conn)
165{
166	u16 command = 0;
167	int rc;
168	bool is_chained = false;
169
170	if (conn->ops->is_transform_hdr &&
171	    conn->ops->is_transform_hdr(work->request_buf)) {
172		rc = conn->ops->decrypt_req(work);
173		if (rc < 0)
174			return;
175		work->encrypted = true;
176	}
177
178	if (conn->ops->allocate_rsp_buf(work))
179		return;
180
181	rc = conn->ops->init_rsp_hdr(work);
182	if (rc) {
183		/* either uid or tid is not correct */
184		conn->ops->set_rsp_status(work, STATUS_INVALID_HANDLE);
185		goto send;
186	}
187
188	do {
189		if (conn->ops->check_user_session) {
190			rc = conn->ops->check_user_session(work);
191			if (rc < 0) {
192				if (rc == -EINVAL)
193					conn->ops->set_rsp_status(work,
194						STATUS_INVALID_PARAMETER);
195				else
196					conn->ops->set_rsp_status(work,
197						STATUS_USER_SESSION_DELETED);
198				goto send;
199			} else if (rc > 0) {
200				rc = conn->ops->get_ksmbd_tcon(work);
201				if (rc < 0) {
202					if (rc == -EINVAL)
203						conn->ops->set_rsp_status(work,
204							STATUS_INVALID_PARAMETER);
205					else
206						conn->ops->set_rsp_status(work,
207							STATUS_NETWORK_NAME_DELETED);
208					goto send;
209				}
210			}
211		}
212
213		rc = __process_request(work, conn, &command);
214		if (rc == SERVER_HANDLER_ABORT)
215			break;
216
217		/*
218		 * Call smb2_set_rsp_credits() function to set number of credits
219		 * granted in hdr of smb2 response.
220		 */
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);
225			if (rc < 0) {
226				conn->ops->set_rsp_status(work,
227					STATUS_INVALID_PARAMETER);
228				goto send;
229			}
230		}
231
232		is_chained = is_chained_smb2_message(work);
233
234		if (work->sess &&
235		    (work->sess->sign || smb3_11_final_sess_setup_resp(work) ||
236		     conn->ops->is_sign_req(work, command)))
237			conn->ops->set_sign_rsp(work);
238	} while (is_chained == true);
239
240send:
241	if (work->tcon)
242		ksmbd_tree_connect_put(work->tcon);
243	smb3_preauth_hash_rsp(work);
244	if (work->sess && work->sess->enc && work->encrypted &&
245	    conn->ops->encrypt_resp) {
246		rc = conn->ops->encrypt_resp(work);
247		if (rc < 0)
248			conn->ops->set_rsp_status(work, STATUS_DATA_ERROR);
249	}
250	if (work->sess)
251		ksmbd_user_session_put(work->sess);
252
253	ksmbd_conn_write(work);
254}
255
256/**
257 * handle_ksmbd_work() - process pending smb work requests
258 * @wk:	smb work containing request command buffer
259 *
260 * called by kworker threads to processing remaining smb work requests
261 */
262static void handle_ksmbd_work(struct work_struct *wk)
263{
264	struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work);
265	struct ksmbd_conn *conn = work->conn;
266
267	atomic64_inc(&conn->stats.request_served);
268
269	__handle_ksmbd_work(work, conn);
270
271	ksmbd_conn_try_dequeue_request(work);
272	ksmbd_free_work_struct(work);
273	ksmbd_conn_r_count_dec(conn);
274}
275
276/**
277 * queue_ksmbd_work() - queue a smb request to worker thread queue
278 *		for processing smb command and sending response
279 * @conn:	connection instance
280 *
281 * read remaining data from socket create and submit work.
282 */
283static int queue_ksmbd_work(struct ksmbd_conn *conn)
284{
285	struct ksmbd_work *work;
286	int err;
287
288	err = ksmbd_init_smb_server(conn);
289	if (err)
290		return 0;
291
292	work = ksmbd_alloc_work_struct();
293	if (!work) {
294		pr_err("allocation for work failed\n");
295		return -ENOMEM;
296	}
297
298	work->conn = conn;
299	work->request_buf = conn->request_buf;
300	conn->request_buf = NULL;
301
302	ksmbd_conn_enqueue_request(work);
303	ksmbd_conn_r_count_inc(conn);
304	/* update activity on connection */
305	conn->last_active = jiffies;
306	INIT_WORK(&work->work, handle_ksmbd_work);
307	ksmbd_queue_work(work);
308	return 0;
309}
310
311static int ksmbd_server_process_request(struct ksmbd_conn *conn)
312{
313	return queue_ksmbd_work(conn);
314}
315
316static int ksmbd_server_terminate_conn(struct ksmbd_conn *conn)
317{
318	ksmbd_sessions_deregister(conn);
319	destroy_lease_table(conn);
320	return 0;
321}
322
323static void ksmbd_server_tcp_callbacks_init(void)
324{
325	struct ksmbd_conn_ops ops;
326
327	ops.process_fn = ksmbd_server_process_request;
328	ops.terminate_fn = ksmbd_server_terminate_conn;
329
330	ksmbd_conn_init_server_callbacks(&ops);
331}
332
333static void server_conf_free(void)
334{
335	int i;
336
337	for (i = 0; i < ARRAY_SIZE(server_conf.conf); i++) {
338		kfree(server_conf.conf[i]);
339		server_conf.conf[i] = NULL;
340	}
341}
342
343static int server_conf_init(void)
344{
345	WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP);
346	server_conf.enforced_signing = 0;
347	server_conf.min_protocol = ksmbd_min_protocol();
348	server_conf.max_protocol = ksmbd_max_protocol();
349	server_conf.auth_mechs = KSMBD_AUTH_NTLMSSP;
350#ifdef CONFIG_SMB_SERVER_KERBEROS5
351	server_conf.auth_mechs |= KSMBD_AUTH_KRB5 |
352				KSMBD_AUTH_MSKRB5;
353#endif
354	server_conf.max_inflight_req = SMB2_MAX_CREDITS;
355	return 0;
356}
357
358static void server_ctrl_handle_init(struct server_ctrl_struct *ctrl)
359{
360	int ret;
361
362	ret = ksmbd_conn_transport_init();
363	if (ret) {
364		server_queue_ctrl_reset_work();
365		return;
366	}
367
368	pr_info("running\n");
369	WRITE_ONCE(server_conf.state, SERVER_STATE_RUNNING);
370}
371
372static void server_ctrl_handle_reset(struct server_ctrl_struct *ctrl)
373{
374	ksmbd_ipc_soft_reset();
375	ksmbd_conn_transport_destroy();
376	ksmbd_stop_durable_scavenger();
377	server_conf_free();
378	server_conf_init();
379	WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP);
380}
381
382static void server_ctrl_handle_work(struct work_struct *work)
383{
384	struct server_ctrl_struct *ctrl;
385
386	ctrl = container_of(work, struct server_ctrl_struct, ctrl_work);
387
388	mutex_lock(&ctrl_lock);
389	switch (ctrl->type) {
390	case SERVER_CTRL_TYPE_INIT:
391		server_ctrl_handle_init(ctrl);
392		break;
393	case SERVER_CTRL_TYPE_RESET:
394		server_ctrl_handle_reset(ctrl);
395		break;
396	default:
397		pr_err("Unknown server work type: %d\n", ctrl->type);
398	}
399	mutex_unlock(&ctrl_lock);
400	kfree(ctrl);
401	module_put(THIS_MODULE);
402}
403
404static int __queue_ctrl_work(int type)
405{
406	struct server_ctrl_struct *ctrl;
407
408	ctrl = kmalloc(sizeof(struct server_ctrl_struct), KSMBD_DEFAULT_GFP);
409	if (!ctrl)
410		return -ENOMEM;
411
412	__module_get(THIS_MODULE);
413	ctrl->type = type;
414	INIT_WORK(&ctrl->ctrl_work, server_ctrl_handle_work);
415	queue_work(system_long_wq, &ctrl->ctrl_work);
416	return 0;
417}
418
419int server_queue_ctrl_init_work(void)
420{
421	return __queue_ctrl_work(SERVER_CTRL_TYPE_INIT);
422}
423
424int server_queue_ctrl_reset_work(void)
425{
426	return __queue_ctrl_work(SERVER_CTRL_TYPE_RESET);
427}
428
429static ssize_t stats_show(const struct class *class, const struct class_attribute *attr,
430			  char *buf)
431{
432	/*
433	 * Inc this each time you change stats output format,
434	 * so user space will know what to do.
435	 */
436	static int stats_version = 2;
437	static const char * const state[] = {
438		"startup",
439		"running",
440		"reset",
441		"shutdown"
442	};
443	return sysfs_emit(buf, "%d %s %d %lu\n", stats_version,
444			  state[server_conf.state], server_conf.tcp_port,
445			  server_conf.ipc_last_active / HZ);
446}
447
448static ssize_t kill_server_store(const struct class *class,
449				 const struct class_attribute *attr, const char *buf,
450				 size_t len)
451{
452	if (!sysfs_streq(buf, "hard"))
453		return len;
454
455	pr_info("kill command received\n");
456	mutex_lock(&ctrl_lock);
457	WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
458	__module_get(THIS_MODULE);
459	server_ctrl_handle_reset(NULL);
460	module_put(THIS_MODULE);
461	mutex_unlock(&ctrl_lock);
462	return len;
463}
464
465static const char * const debug_type_strings[] = {"smb", "auth", "vfs",
466						  "oplock", "ipc", "conn",
467						  "rdma"};
468
469static ssize_t debug_show(const struct class *class, const struct class_attribute *attr,
470			  char *buf)
471{
472	ssize_t sz = 0;
473	int i, pos = 0;
474
475	for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) {
476		if ((ksmbd_debug_types >> i) & 1) {
477			pos = sysfs_emit_at(buf, sz, "[%s] ", debug_type_strings[i]);
478		} else {
479			pos = sysfs_emit_at(buf, sz, "%s ", debug_type_strings[i]);
480		}
481		sz += pos;
482	}
483	sz += sysfs_emit_at(buf, sz, "\n");
484	return sz;
485}
486
487static ssize_t debug_store(const struct class *class, const struct class_attribute *attr,
488			   const char *buf, size_t len)
489{
490	int i;
491
492	for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) {
493		if (sysfs_streq(buf, "all")) {
494			if (ksmbd_debug_types == KSMBD_DEBUG_ALL)
495				ksmbd_debug_types = 0;
496			else
497				ksmbd_debug_types = KSMBD_DEBUG_ALL;
498			break;
499		}
500
501		if (sysfs_streq(buf, debug_type_strings[i])) {
502			if (ksmbd_debug_types & (1 << i))
503				ksmbd_debug_types &= ~(1 << i);
504			else
505				ksmbd_debug_types |= (1 << i);
506			break;
507		}
508	}
509
510	return len;
511}
512
513static CLASS_ATTR_RO(stats);
514static CLASS_ATTR_WO(kill_server);
515static CLASS_ATTR_RW(debug);
516
517static struct attribute *ksmbd_control_class_attrs[] = {
518	&class_attr_stats.attr,
519	&class_attr_kill_server.attr,
520	&class_attr_debug.attr,
521	NULL,
522};
523ATTRIBUTE_GROUPS(ksmbd_control_class);
524
525static struct class ksmbd_control_class = {
526	.name		= "ksmbd-control",
527	.class_groups	= ksmbd_control_class_groups,
528};
529
530static int ksmbd_server_shutdown(void)
531{
532	WRITE_ONCE(server_conf.state, SERVER_STATE_SHUTTING_DOWN);
533
534	class_unregister(&ksmbd_control_class);
535	ksmbd_workqueue_destroy();
536	ksmbd_ipc_release();
537	ksmbd_conn_transport_destroy();
538	ksmbd_crypto_destroy();
539	ksmbd_free_global_file_table();
540	destroy_lease_table(NULL);
541	ksmbd_work_pool_destroy();
542	ksmbd_exit_file_cache();
543	server_conf_free();
544	return 0;
545}
546
547static int __init ksmbd_server_init(void)
548{
549	int ret;
550
551	ret = class_register(&ksmbd_control_class);
552	if (ret) {
553		pr_err("Unable to register ksmbd-control class\n");
554		return ret;
555	}
556
557	ksmbd_server_tcp_callbacks_init();
558
559	ret = server_conf_init();
560	if (ret)
561		goto err_unregister;
562
563	ret = ksmbd_work_pool_init();
564	if (ret)
565		goto err_unregister;
566
567	ret = ksmbd_init_file_cache();
568	if (ret)
569		goto err_destroy_work_pools;
570
571	ret = ksmbd_ipc_init();
572	if (ret)
573		goto err_exit_file_cache;
574
575	ret = ksmbd_init_global_file_table();
576	if (ret)
577		goto err_ipc_release;
578
579	ret = ksmbd_inode_hash_init();
580	if (ret)
581		goto err_destroy_file_table;
582
583	ret = ksmbd_crypto_create();
584	if (ret)
585		goto err_release_inode_hash;
586
587	ret = ksmbd_workqueue_init();
588	if (ret)
589		goto err_crypto_destroy;
590
591	return 0;
592
593err_crypto_destroy:
594	ksmbd_crypto_destroy();
595err_release_inode_hash:
596	ksmbd_release_inode_hash();
597err_destroy_file_table:
598	ksmbd_free_global_file_table();
599err_ipc_release:
600	ksmbd_ipc_release();
601err_exit_file_cache:
602	ksmbd_exit_file_cache();
603err_destroy_work_pools:
604	ksmbd_work_pool_destroy();
605err_unregister:
606	class_unregister(&ksmbd_control_class);
607
608	return ret;
609}
610
611/**
612 * ksmbd_server_exit() - shutdown forker thread and free memory at module exit
613 */
614static void __exit ksmbd_server_exit(void)
615{
616	ksmbd_server_shutdown();
617	rcu_barrier();
618	ksmbd_release_inode_hash();
619}
620
621MODULE_AUTHOR("Namjae Jeon <linkinjeon@kernel.org>");
622MODULE_DESCRIPTION("Linux kernel CIFS/SMB SERVER");
623MODULE_LICENSE("GPL");
624MODULE_SOFTDEP("pre: ecb");
625MODULE_SOFTDEP("pre: nls");
626MODULE_SOFTDEP("pre: aes");
627MODULE_SOFTDEP("pre: cmac");
628MODULE_SOFTDEP("pre: aead2");
629MODULE_SOFTDEP("pre: ccm");
630MODULE_SOFTDEP("pre: gcm");
631module_init(ksmbd_server_init)
632module_exit(ksmbd_server_exit)