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 "smbstatus.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 25 int ksmbd_debug_types; 26 27 struct ksmbd_server_config server_conf; 28 29 enum SERVER_CTRL_TYPE { 30 SERVER_CTRL_TYPE_INIT, 31 SERVER_CTRL_TYPE_RESET, 32 }; 33 34 struct server_ctrl_struct { 35 int type; 36 struct work_struct ctrl_work; 37 }; 38 39 static DEFINE_MUTEX(ctrl_lock); 40 41 static 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, GFP_KERNEL); 51 if (!server_conf.conf[idx]) 52 return -ENOMEM; 53 return 0; 54 } 55 56 int ksmbd_set_netbios_name(char *v) 57 { 58 return ___server_conf_set(SERVER_CONF_NETBIOS_NAME, v); 59 } 60 61 int ksmbd_set_server_string(char *v) 62 { 63 return ___server_conf_set(SERVER_CONF_SERVER_STRING, v); 64 } 65 66 int ksmbd_set_work_group(char *v) 67 { 68 return ___server_conf_set(SERVER_CONF_WORK_GROUP, v); 69 } 70 71 char *ksmbd_netbios_name(void) 72 { 73 return server_conf.conf[SERVER_CONF_NETBIOS_NAME]; 74 } 75 76 char *ksmbd_server_string(void) 77 { 78 return server_conf.conf[SERVER_CONF_SERVER_STRING]; 79 } 80 81 char *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 */ 92 static 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 = 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 108 static 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 126 andx_again: 127 if (command >= conn->max_cmds) { 128 conn->ops->set_rsp_status(work, STATUS_INVALID_PARAMETER); 129 return SERVER_HANDLER_CONTINUE; 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_CONTINUE; 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_CONTINUE; 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 163 static 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 240 send: 241 if (work->tcon) 242 ksmbd_tree_connect_put(work->tcon); 243 smb3_preauth_hash_rsp(work); 244 if (work->sess) 245 ksmbd_user_session_put(work->sess); 246 if (work->sess && work->sess->enc && work->encrypted && 247 conn->ops->encrypt_resp) { 248 rc = conn->ops->encrypt_resp(work); 249 if (rc < 0) 250 conn->ops->set_rsp_status(work, STATUS_DATA_ERROR); 251 } 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 */ 262 static 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 atomic_dec(&conn->mux_smb_requests); 274 /* 275 * Checking waitqueue to dropping pending requests on 276 * disconnection. waitqueue_active is safe because it 277 * uses atomic operation for condition. 278 */ 279 atomic_inc(&conn->refcnt); 280 if (!atomic_dec_return(&conn->r_count) && waitqueue_active(&conn->r_count_q)) 281 wake_up(&conn->r_count_q); 282 283 if (atomic_dec_and_test(&conn->refcnt)) 284 kfree(conn); 285 } 286 287 /** 288 * queue_ksmbd_work() - queue a smb request to worker thread queue 289 * for proccessing smb command and sending response 290 * @conn: connection instance 291 * 292 * read remaining data from socket create and submit work. 293 */ 294 static int queue_ksmbd_work(struct ksmbd_conn *conn) 295 { 296 struct ksmbd_work *work; 297 int err; 298 299 err = ksmbd_init_smb_server(conn); 300 if (err) 301 return 0; 302 303 if (atomic_inc_return(&conn->mux_smb_requests) >= conn->vals->max_credits) { 304 atomic_dec_return(&conn->mux_smb_requests); 305 return -ENOSPC; 306 } 307 308 work = ksmbd_alloc_work_struct(); 309 if (!work) { 310 pr_err("allocation for work failed\n"); 311 return -ENOMEM; 312 } 313 314 work->conn = conn; 315 work->request_buf = conn->request_buf; 316 conn->request_buf = NULL; 317 318 ksmbd_conn_enqueue_request(work); 319 atomic_inc(&conn->r_count); 320 /* update activity on connection */ 321 conn->last_active = jiffies; 322 INIT_WORK(&work->work, handle_ksmbd_work); 323 ksmbd_queue_work(work); 324 return 0; 325 } 326 327 static int ksmbd_server_process_request(struct ksmbd_conn *conn) 328 { 329 return queue_ksmbd_work(conn); 330 } 331 332 static int ksmbd_server_terminate_conn(struct ksmbd_conn *conn) 333 { 334 ksmbd_sessions_deregister(conn); 335 destroy_lease_table(conn); 336 return 0; 337 } 338 339 static void ksmbd_server_tcp_callbacks_init(void) 340 { 341 struct ksmbd_conn_ops ops; 342 343 ops.process_fn = ksmbd_server_process_request; 344 ops.terminate_fn = ksmbd_server_terminate_conn; 345 346 ksmbd_conn_init_server_callbacks(&ops); 347 } 348 349 static void server_conf_free(void) 350 { 351 int i; 352 353 for (i = 0; i < ARRAY_SIZE(server_conf.conf); i++) { 354 kfree(server_conf.conf[i]); 355 server_conf.conf[i] = NULL; 356 } 357 } 358 359 static int server_conf_init(void) 360 { 361 WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP); 362 server_conf.enforced_signing = 0; 363 server_conf.min_protocol = ksmbd_min_protocol(); 364 server_conf.max_protocol = ksmbd_max_protocol(); 365 server_conf.auth_mechs = KSMBD_AUTH_NTLMSSP; 366 #ifdef CONFIG_SMB_SERVER_KERBEROS5 367 server_conf.auth_mechs |= KSMBD_AUTH_KRB5 | 368 KSMBD_AUTH_MSKRB5; 369 #endif 370 return 0; 371 } 372 373 static void server_ctrl_handle_init(struct server_ctrl_struct *ctrl) 374 { 375 int ret; 376 377 ret = ksmbd_conn_transport_init(); 378 if (ret) { 379 server_queue_ctrl_reset_work(); 380 return; 381 } 382 383 WRITE_ONCE(server_conf.state, SERVER_STATE_RUNNING); 384 } 385 386 static void server_ctrl_handle_reset(struct server_ctrl_struct *ctrl) 387 { 388 ksmbd_ipc_soft_reset(); 389 ksmbd_conn_transport_destroy(); 390 server_conf_free(); 391 server_conf_init(); 392 WRITE_ONCE(server_conf.state, SERVER_STATE_STARTING_UP); 393 } 394 395 static void server_ctrl_handle_work(struct work_struct *work) 396 { 397 struct server_ctrl_struct *ctrl; 398 399 ctrl = container_of(work, struct server_ctrl_struct, ctrl_work); 400 401 mutex_lock(&ctrl_lock); 402 switch (ctrl->type) { 403 case SERVER_CTRL_TYPE_INIT: 404 server_ctrl_handle_init(ctrl); 405 break; 406 case SERVER_CTRL_TYPE_RESET: 407 server_ctrl_handle_reset(ctrl); 408 break; 409 default: 410 pr_err("Unknown server work type: %d\n", ctrl->type); 411 } 412 mutex_unlock(&ctrl_lock); 413 kfree(ctrl); 414 module_put(THIS_MODULE); 415 } 416 417 static int __queue_ctrl_work(int type) 418 { 419 struct server_ctrl_struct *ctrl; 420 421 ctrl = kmalloc(sizeof(struct server_ctrl_struct), GFP_KERNEL); 422 if (!ctrl) 423 return -ENOMEM; 424 425 __module_get(THIS_MODULE); 426 ctrl->type = type; 427 INIT_WORK(&ctrl->ctrl_work, server_ctrl_handle_work); 428 queue_work(system_long_wq, &ctrl->ctrl_work); 429 return 0; 430 } 431 432 int server_queue_ctrl_init_work(void) 433 { 434 return __queue_ctrl_work(SERVER_CTRL_TYPE_INIT); 435 } 436 437 int server_queue_ctrl_reset_work(void) 438 { 439 return __queue_ctrl_work(SERVER_CTRL_TYPE_RESET); 440 } 441 442 static ssize_t stats_show(const struct class *class, const struct class_attribute *attr, 443 char *buf) 444 { 445 /* 446 * Inc this each time you change stats output format, 447 * so user space will know what to do. 448 */ 449 static int stats_version = 2; 450 static const char * const state[] = { 451 "startup", 452 "running", 453 "reset", 454 "shutdown" 455 }; 456 return sysfs_emit(buf, "%d %s %d %lu\n", stats_version, 457 state[server_conf.state], server_conf.tcp_port, 458 server_conf.ipc_last_active / HZ); 459 } 460 461 static ssize_t kill_server_store(const struct class *class, 462 const struct class_attribute *attr, const char *buf, 463 size_t len) 464 { 465 if (!sysfs_streq(buf, "hard")) 466 return len; 467 468 pr_info("kill command received\n"); 469 mutex_lock(&ctrl_lock); 470 WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING); 471 __module_get(THIS_MODULE); 472 server_ctrl_handle_reset(NULL); 473 module_put(THIS_MODULE); 474 mutex_unlock(&ctrl_lock); 475 return len; 476 } 477 478 static const char * const debug_type_strings[] = {"smb", "auth", "vfs", 479 "oplock", "ipc", "conn", 480 "rdma"}; 481 482 static ssize_t debug_show(const struct class *class, const struct class_attribute *attr, 483 char *buf) 484 { 485 ssize_t sz = 0; 486 int i, pos = 0; 487 488 for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) { 489 if ((ksmbd_debug_types >> i) & 1) { 490 pos = sysfs_emit_at(buf, sz, "[%s] ", debug_type_strings[i]); 491 } else { 492 pos = sysfs_emit_at(buf, sz, "%s ", debug_type_strings[i]); 493 } 494 sz += pos; 495 } 496 sz += sysfs_emit_at(buf, sz, "\n"); 497 return sz; 498 } 499 500 static ssize_t debug_store(const struct class *class, const struct class_attribute *attr, 501 const char *buf, size_t len) 502 { 503 int i; 504 505 for (i = 0; i < ARRAY_SIZE(debug_type_strings); i++) { 506 if (sysfs_streq(buf, "all")) { 507 if (ksmbd_debug_types == KSMBD_DEBUG_ALL) 508 ksmbd_debug_types = 0; 509 else 510 ksmbd_debug_types = KSMBD_DEBUG_ALL; 511 break; 512 } 513 514 if (sysfs_streq(buf, debug_type_strings[i])) { 515 if (ksmbd_debug_types & (1 << i)) 516 ksmbd_debug_types &= ~(1 << i); 517 else 518 ksmbd_debug_types |= (1 << i); 519 break; 520 } 521 } 522 523 return len; 524 } 525 526 static CLASS_ATTR_RO(stats); 527 static CLASS_ATTR_WO(kill_server); 528 static CLASS_ATTR_RW(debug); 529 530 static struct attribute *ksmbd_control_class_attrs[] = { 531 &class_attr_stats.attr, 532 &class_attr_kill_server.attr, 533 &class_attr_debug.attr, 534 NULL, 535 }; 536 ATTRIBUTE_GROUPS(ksmbd_control_class); 537 538 static struct class ksmbd_control_class = { 539 .name = "ksmbd-control", 540 .class_groups = ksmbd_control_class_groups, 541 }; 542 543 static int ksmbd_server_shutdown(void) 544 { 545 WRITE_ONCE(server_conf.state, SERVER_STATE_SHUTTING_DOWN); 546 547 class_unregister(&ksmbd_control_class); 548 ksmbd_workqueue_destroy(); 549 ksmbd_ipc_release(); 550 ksmbd_conn_transport_destroy(); 551 ksmbd_crypto_destroy(); 552 ksmbd_free_global_file_table(); 553 destroy_lease_table(NULL); 554 ksmbd_work_pool_destroy(); 555 ksmbd_exit_file_cache(); 556 server_conf_free(); 557 return 0; 558 } 559 560 static int __init ksmbd_server_init(void) 561 { 562 int ret; 563 564 ret = class_register(&ksmbd_control_class); 565 if (ret) { 566 pr_err("Unable to register ksmbd-control class\n"); 567 return ret; 568 } 569 570 ksmbd_server_tcp_callbacks_init(); 571 572 ret = server_conf_init(); 573 if (ret) 574 goto err_unregister; 575 576 ret = ksmbd_work_pool_init(); 577 if (ret) 578 goto err_unregister; 579 580 ret = ksmbd_init_file_cache(); 581 if (ret) 582 goto err_destroy_work_pools; 583 584 ret = ksmbd_ipc_init(); 585 if (ret) 586 goto err_exit_file_cache; 587 588 ret = ksmbd_init_global_file_table(); 589 if (ret) 590 goto err_ipc_release; 591 592 ret = ksmbd_inode_hash_init(); 593 if (ret) 594 goto err_destroy_file_table; 595 596 ret = ksmbd_crypto_create(); 597 if (ret) 598 goto err_release_inode_hash; 599 600 ret = ksmbd_workqueue_init(); 601 if (ret) 602 goto err_crypto_destroy; 603 604 return 0; 605 606 err_crypto_destroy: 607 ksmbd_crypto_destroy(); 608 err_release_inode_hash: 609 ksmbd_release_inode_hash(); 610 err_destroy_file_table: 611 ksmbd_free_global_file_table(); 612 err_ipc_release: 613 ksmbd_ipc_release(); 614 err_exit_file_cache: 615 ksmbd_exit_file_cache(); 616 err_destroy_work_pools: 617 ksmbd_work_pool_destroy(); 618 err_unregister: 619 class_unregister(&ksmbd_control_class); 620 621 return ret; 622 } 623 624 /** 625 * ksmbd_server_exit() - shutdown forker thread and free memory at module exit 626 */ 627 static void __exit ksmbd_server_exit(void) 628 { 629 ksmbd_server_shutdown(); 630 rcu_barrier(); 631 ksmbd_release_inode_hash(); 632 } 633 634 MODULE_AUTHOR("Namjae Jeon <linkinjeon@kernel.org>"); 635 MODULE_VERSION(KSMBD_VERSION); 636 MODULE_DESCRIPTION("Linux kernel CIFS/SMB SERVER"); 637 MODULE_LICENSE("GPL"); 638 MODULE_SOFTDEP("pre: ecb"); 639 MODULE_SOFTDEP("pre: hmac"); 640 MODULE_SOFTDEP("pre: md5"); 641 MODULE_SOFTDEP("pre: nls"); 642 MODULE_SOFTDEP("pre: aes"); 643 MODULE_SOFTDEP("pre: cmac"); 644 MODULE_SOFTDEP("pre: sha256"); 645 MODULE_SOFTDEP("pre: sha512"); 646 MODULE_SOFTDEP("pre: aead2"); 647 MODULE_SOFTDEP("pre: ccm"); 648 MODULE_SOFTDEP("pre: gcm"); 649 MODULE_SOFTDEP("pre: crc32"); 650 module_init(ksmbd_server_init) 651 module_exit(ksmbd_server_exit) 652