1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
6 #include <linux/jhash.h>
7 #include <linux/slab.h>
8 #include <linux/rwsem.h>
9 #include <linux/mutex.h>
10 #include <linux/wait.h>
11 #include <linux/hashtable.h>
12 #include <net/net_namespace.h>
13 #include <net/genetlink.h>
14 #include <linux/socket.h>
15 #include <linux/workqueue.h>
17 #include "vfs_cache.h"
18 #include "transport_ipc.h"
20 #include "smb_common.h"
22 #include "mgmt/user_config.h"
23 #include "mgmt/share_config.h"
24 #include "mgmt/user_session.h"
25 #include "mgmt/tree_connect.h"
26 #include "mgmt/ksmbd_ida.h"
27 #include "connection.h"
28 #include "transport_tcp.h"
29 #include "transport_rdma.h"
31 #define IPC_WAIT_TIMEOUT (2 * HZ)
33 #define IPC_MSG_HASH_BITS 3
34 static DEFINE_HASHTABLE(ipc_msg_table, IPC_MSG_HASH_BITS);
35 static DECLARE_RWSEM(ipc_msg_table_lock);
36 static DEFINE_MUTEX(startup_lock);
38 static DEFINE_IDA(ipc_ida);
40 static unsigned int ksmbd_tools_pid;
42 static bool ksmbd_ipc_validate_version(struct genl_info *m)
44 if (m->genlhdr->version != KSMBD_GENL_VERSION) {
45 pr_err("%s. ksmbd: %d, kernel module: %d. %s.\n",
46 "Daemon and kernel module version mismatch",
49 "User-space ksmbd should terminate");
55 struct ksmbd_ipc_msg {
58 unsigned char payload[];
61 struct ipc_msg_table_entry {
64 wait_queue_head_t wait;
65 struct hlist_node ipc_table_hlist;
70 static struct delayed_work ipc_timer_work;
72 static int handle_startup_event(struct sk_buff *skb, struct genl_info *info);
73 static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info);
74 static int handle_generic_event(struct sk_buff *skb, struct genl_info *info);
75 static int ksmbd_ipc_heartbeat_request(void);
77 static const struct nla_policy ksmbd_nl_policy[KSMBD_EVENT_MAX] = {
78 [KSMBD_EVENT_UNSPEC] = {
81 [KSMBD_EVENT_HEARTBEAT_REQUEST] = {
82 .len = sizeof(struct ksmbd_heartbeat),
84 [KSMBD_EVENT_STARTING_UP] = {
85 .len = sizeof(struct ksmbd_startup_request),
87 [KSMBD_EVENT_SHUTTING_DOWN] = {
88 .len = sizeof(struct ksmbd_shutdown_request),
90 [KSMBD_EVENT_LOGIN_REQUEST] = {
91 .len = sizeof(struct ksmbd_login_request),
93 [KSMBD_EVENT_LOGIN_RESPONSE] = {
94 .len = sizeof(struct ksmbd_login_response),
96 [KSMBD_EVENT_SHARE_CONFIG_REQUEST] = {
97 .len = sizeof(struct ksmbd_share_config_request),
99 [KSMBD_EVENT_SHARE_CONFIG_RESPONSE] = {
100 .len = sizeof(struct ksmbd_share_config_response),
102 [KSMBD_EVENT_TREE_CONNECT_REQUEST] = {
103 .len = sizeof(struct ksmbd_tree_connect_request),
105 [KSMBD_EVENT_TREE_CONNECT_RESPONSE] = {
106 .len = sizeof(struct ksmbd_tree_connect_response),
108 [KSMBD_EVENT_TREE_DISCONNECT_REQUEST] = {
109 .len = sizeof(struct ksmbd_tree_disconnect_request),
111 [KSMBD_EVENT_LOGOUT_REQUEST] = {
112 .len = sizeof(struct ksmbd_logout_request),
114 [KSMBD_EVENT_RPC_REQUEST] = {
116 [KSMBD_EVENT_RPC_RESPONSE] = {
118 [KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST] = {
120 [KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE] = {
124 static struct genl_ops ksmbd_genl_ops[] = {
126 .cmd = KSMBD_EVENT_UNSPEC,
127 .doit = handle_unsupported_event,
130 .cmd = KSMBD_EVENT_HEARTBEAT_REQUEST,
131 .doit = handle_unsupported_event,
134 .cmd = KSMBD_EVENT_STARTING_UP,
135 .doit = handle_startup_event,
138 .cmd = KSMBD_EVENT_SHUTTING_DOWN,
139 .doit = handle_unsupported_event,
142 .cmd = KSMBD_EVENT_LOGIN_REQUEST,
143 .doit = handle_unsupported_event,
146 .cmd = KSMBD_EVENT_LOGIN_RESPONSE,
147 .doit = handle_generic_event,
150 .cmd = KSMBD_EVENT_SHARE_CONFIG_REQUEST,
151 .doit = handle_unsupported_event,
154 .cmd = KSMBD_EVENT_SHARE_CONFIG_RESPONSE,
155 .doit = handle_generic_event,
158 .cmd = KSMBD_EVENT_TREE_CONNECT_REQUEST,
159 .doit = handle_unsupported_event,
162 .cmd = KSMBD_EVENT_TREE_CONNECT_RESPONSE,
163 .doit = handle_generic_event,
166 .cmd = KSMBD_EVENT_TREE_DISCONNECT_REQUEST,
167 .doit = handle_unsupported_event,
170 .cmd = KSMBD_EVENT_LOGOUT_REQUEST,
171 .doit = handle_unsupported_event,
174 .cmd = KSMBD_EVENT_RPC_REQUEST,
175 .doit = handle_unsupported_event,
178 .cmd = KSMBD_EVENT_RPC_RESPONSE,
179 .doit = handle_generic_event,
182 .cmd = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST,
183 .doit = handle_unsupported_event,
186 .cmd = KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE,
187 .doit = handle_generic_event,
191 static struct genl_family ksmbd_genl_family = {
192 .name = KSMBD_GENL_NAME,
193 .version = KSMBD_GENL_VERSION,
195 .maxattr = KSMBD_EVENT_MAX,
197 .module = THIS_MODULE,
198 .ops = ksmbd_genl_ops,
199 .n_ops = ARRAY_SIZE(ksmbd_genl_ops),
202 static void ksmbd_nl_init_fixup(void)
206 for (i = 0; i < ARRAY_SIZE(ksmbd_genl_ops); i++)
207 ksmbd_genl_ops[i].validate = GENL_DONT_VALIDATE_STRICT |
208 GENL_DONT_VALIDATE_DUMP;
210 ksmbd_genl_family.policy = ksmbd_nl_policy;
213 static int rpc_context_flags(struct ksmbd_session *sess)
215 if (user_guest(sess->user))
216 return KSMBD_RPC_RESTRICTED_CONTEXT;
220 static void ipc_update_last_active(void)
222 if (server_conf.ipc_timeout)
223 server_conf.ipc_last_active = jiffies;
226 static struct ksmbd_ipc_msg *ipc_msg_alloc(size_t sz)
228 struct ksmbd_ipc_msg *msg;
229 size_t msg_sz = sz + sizeof(struct ksmbd_ipc_msg);
231 msg = kvmalloc(msg_sz, GFP_KERNEL | __GFP_ZERO);
237 static void ipc_msg_free(struct ksmbd_ipc_msg *msg)
242 static void ipc_msg_handle_free(int handle)
245 ksmbd_release_id(&ipc_ida, handle);
248 static int handle_response(int type, void *payload, size_t sz)
250 unsigned int handle = *(unsigned int *)payload;
251 struct ipc_msg_table_entry *entry;
254 ipc_update_last_active();
255 down_read(&ipc_msg_table_lock);
256 hash_for_each_possible(ipc_msg_table, entry, ipc_table_hlist, handle) {
257 if (handle != entry->handle)
260 entry->response = NULL;
262 * Response message type value should be equal to
263 * request message type + 1.
265 if (entry->type + 1 != type) {
266 pr_err("Waiting for IPC type %d, got %d. Ignore.\n",
267 entry->type + 1, type);
270 entry->response = kvmalloc(sz, GFP_KERNEL | __GFP_ZERO);
271 if (!entry->response) {
276 memcpy(entry->response, payload, sz);
277 wake_up_interruptible(&entry->wait);
281 up_read(&ipc_msg_table_lock);
286 static int ipc_server_config_on_startup(struct ksmbd_startup_request *req)
290 ksmbd_set_fd_limit(req->file_max);
291 server_conf.flags = req->flags;
292 server_conf.signing = req->signing;
293 server_conf.tcp_port = req->tcp_port;
294 server_conf.ipc_timeout = req->ipc_timeout * HZ;
295 server_conf.deadtime = req->deadtime * SMB_ECHO_INTERVAL;
296 server_conf.share_fake_fscaps = req->share_fake_fscaps;
297 ksmbd_init_domain(req->sub_auth);
299 if (req->smb2_max_read)
300 init_smb2_max_read_size(req->smb2_max_read);
301 if (req->smb2_max_write)
302 init_smb2_max_write_size(req->smb2_max_write);
303 if (req->smb2_max_trans)
304 init_smb2_max_trans_size(req->smb2_max_trans);
305 if (req->smb2_max_credits)
306 init_smb2_max_credits(req->smb2_max_credits);
307 if (req->smbd_max_io_size)
308 init_smbd_max_io_size(req->smbd_max_io_size);
310 ret = ksmbd_set_netbios_name(req->netbios_name);
311 ret |= ksmbd_set_server_string(req->server_string);
312 ret |= ksmbd_set_work_group(req->work_group);
313 ret |= ksmbd_tcp_set_interfaces(KSMBD_STARTUP_CONFIG_INTERFACES(req),
316 pr_err("Server configuration error: %s %s %s\n",
317 req->netbios_name, req->server_string,
322 if (req->min_prot[0]) {
323 ret = ksmbd_lookup_protocol_idx(req->min_prot);
325 server_conf.min_protocol = ret;
327 if (req->max_prot[0]) {
328 ret = ksmbd_lookup_protocol_idx(req->max_prot);
330 server_conf.max_protocol = ret;
333 if (server_conf.ipc_timeout)
334 schedule_delayed_work(&ipc_timer_work, server_conf.ipc_timeout);
338 static int handle_startup_event(struct sk_buff *skb, struct genl_info *info)
342 #ifdef CONFIG_SMB_SERVER_CHECK_CAP_NET_ADMIN
343 if (!netlink_capable(skb, CAP_NET_ADMIN))
347 if (!ksmbd_ipc_validate_version(info))
350 if (!info->attrs[KSMBD_EVENT_STARTING_UP])
353 mutex_lock(&startup_lock);
354 if (!ksmbd_server_configurable()) {
355 mutex_unlock(&startup_lock);
356 pr_err("Server reset is in progress, can't start daemon\n");
360 if (ksmbd_tools_pid) {
361 if (ksmbd_ipc_heartbeat_request() == 0) {
366 pr_err("Reconnect to a new user space daemon\n");
368 struct ksmbd_startup_request *req;
370 req = nla_data(info->attrs[info->genlhdr->cmd]);
371 ret = ipc_server_config_on_startup(req);
374 server_queue_ctrl_init_work();
377 ksmbd_tools_pid = info->snd_portid;
378 ipc_update_last_active();
381 mutex_unlock(&startup_lock);
385 static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info)
387 pr_err("Unknown IPC event: %d, ignore.\n", info->genlhdr->cmd);
391 static int handle_generic_event(struct sk_buff *skb, struct genl_info *info)
395 int type = info->genlhdr->cmd;
397 #ifdef CONFIG_SMB_SERVER_CHECK_CAP_NET_ADMIN
398 if (!netlink_capable(skb, CAP_NET_ADMIN))
402 if (type >= KSMBD_EVENT_MAX) {
407 if (!ksmbd_ipc_validate_version(info))
410 if (!info->attrs[type])
413 payload = nla_data(info->attrs[info->genlhdr->cmd]);
414 sz = nla_len(info->attrs[info->genlhdr->cmd]);
415 return handle_response(type, payload, sz);
418 static int ipc_msg_send(struct ksmbd_ipc_msg *msg)
420 struct genlmsghdr *nlh;
424 if (!ksmbd_tools_pid)
427 skb = genlmsg_new(msg->sz, GFP_KERNEL);
431 nlh = genlmsg_put(skb, 0, 0, &ksmbd_genl_family, 0, msg->type);
435 ret = nla_put(skb, msg->type, msg->sz, msg->payload);
437 genlmsg_cancel(skb, nlh);
441 genlmsg_end(skb, nlh);
442 ret = genlmsg_unicast(&init_net, skb, ksmbd_tools_pid);
444 ipc_update_last_active();
452 static void *ipc_msg_send_request(struct ksmbd_ipc_msg *msg, unsigned int handle)
454 struct ipc_msg_table_entry entry;
460 entry.type = msg->type;
461 entry.response = NULL;
462 init_waitqueue_head(&entry.wait);
464 down_write(&ipc_msg_table_lock);
465 entry.handle = handle;
466 hash_add(ipc_msg_table, &entry.ipc_table_hlist, entry.handle);
467 up_write(&ipc_msg_table_lock);
469 ret = ipc_msg_send(msg);
473 ret = wait_event_interruptible_timeout(entry.wait,
474 entry.response != NULL,
477 down_write(&ipc_msg_table_lock);
478 hash_del(&entry.ipc_table_hlist);
479 up_write(&ipc_msg_table_lock);
480 return entry.response;
483 static int ksmbd_ipc_heartbeat_request(void)
485 struct ksmbd_ipc_msg *msg;
488 msg = ipc_msg_alloc(sizeof(struct ksmbd_heartbeat));
492 msg->type = KSMBD_EVENT_HEARTBEAT_REQUEST;
493 ret = ipc_msg_send(msg);
498 struct ksmbd_login_response *ksmbd_ipc_login_request(const char *account)
500 struct ksmbd_ipc_msg *msg;
501 struct ksmbd_login_request *req;
502 struct ksmbd_login_response *resp;
504 if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
507 msg = ipc_msg_alloc(sizeof(struct ksmbd_login_request));
511 msg->type = KSMBD_EVENT_LOGIN_REQUEST;
512 req = (struct ksmbd_login_request *)msg->payload;
513 req->handle = ksmbd_acquire_id(&ipc_ida);
514 strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
516 resp = ipc_msg_send_request(msg, req->handle);
517 ipc_msg_handle_free(req->handle);
522 struct ksmbd_spnego_authen_response *
523 ksmbd_ipc_spnego_authen_request(const char *spnego_blob, int blob_len)
525 struct ksmbd_ipc_msg *msg;
526 struct ksmbd_spnego_authen_request *req;
527 struct ksmbd_spnego_authen_response *resp;
529 msg = ipc_msg_alloc(sizeof(struct ksmbd_spnego_authen_request) +
534 msg->type = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST;
535 req = (struct ksmbd_spnego_authen_request *)msg->payload;
536 req->handle = ksmbd_acquire_id(&ipc_ida);
537 req->spnego_blob_len = blob_len;
538 memcpy(req->spnego_blob, spnego_blob, blob_len);
540 resp = ipc_msg_send_request(msg, req->handle);
541 ipc_msg_handle_free(req->handle);
546 struct ksmbd_tree_connect_response *
547 ksmbd_ipc_tree_connect_request(struct ksmbd_session *sess,
548 struct ksmbd_share_config *share,
549 struct ksmbd_tree_connect *tree_conn,
550 struct sockaddr *peer_addr)
552 struct ksmbd_ipc_msg *msg;
553 struct ksmbd_tree_connect_request *req;
554 struct ksmbd_tree_connect_response *resp;
556 if (strlen(user_name(sess->user)) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
559 if (strlen(share->name) >= KSMBD_REQ_MAX_SHARE_NAME)
562 msg = ipc_msg_alloc(sizeof(struct ksmbd_tree_connect_request));
566 msg->type = KSMBD_EVENT_TREE_CONNECT_REQUEST;
567 req = (struct ksmbd_tree_connect_request *)msg->payload;
569 req->handle = ksmbd_acquire_id(&ipc_ida);
570 req->account_flags = sess->user->flags;
571 req->session_id = sess->id;
572 req->connect_id = tree_conn->id;
573 strscpy(req->account, user_name(sess->user), KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
574 strscpy(req->share, share->name, KSMBD_REQ_MAX_SHARE_NAME);
575 snprintf(req->peer_addr, sizeof(req->peer_addr), "%pIS", peer_addr);
577 if (peer_addr->sa_family == AF_INET6)
578 req->flags |= KSMBD_TREE_CONN_FLAG_REQUEST_IPV6;
579 if (test_session_flag(sess, CIFDS_SESSION_FLAG_SMB2))
580 req->flags |= KSMBD_TREE_CONN_FLAG_REQUEST_SMB2;
582 resp = ipc_msg_send_request(msg, req->handle);
583 ipc_msg_handle_free(req->handle);
588 int ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,
589 unsigned long long connect_id)
591 struct ksmbd_ipc_msg *msg;
592 struct ksmbd_tree_disconnect_request *req;
595 msg = ipc_msg_alloc(sizeof(struct ksmbd_tree_disconnect_request));
599 msg->type = KSMBD_EVENT_TREE_DISCONNECT_REQUEST;
600 req = (struct ksmbd_tree_disconnect_request *)msg->payload;
601 req->session_id = session_id;
602 req->connect_id = connect_id;
604 ret = ipc_msg_send(msg);
609 int ksmbd_ipc_logout_request(const char *account, int flags)
611 struct ksmbd_ipc_msg *msg;
612 struct ksmbd_logout_request *req;
615 if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
618 msg = ipc_msg_alloc(sizeof(struct ksmbd_logout_request));
622 msg->type = KSMBD_EVENT_LOGOUT_REQUEST;
623 req = (struct ksmbd_logout_request *)msg->payload;
624 req->account_flags = flags;
625 strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
627 ret = ipc_msg_send(msg);
632 struct ksmbd_share_config_response *
633 ksmbd_ipc_share_config_request(const char *name)
635 struct ksmbd_ipc_msg *msg;
636 struct ksmbd_share_config_request *req;
637 struct ksmbd_share_config_response *resp;
639 if (strlen(name) >= KSMBD_REQ_MAX_SHARE_NAME)
642 msg = ipc_msg_alloc(sizeof(struct ksmbd_share_config_request));
646 msg->type = KSMBD_EVENT_SHARE_CONFIG_REQUEST;
647 req = (struct ksmbd_share_config_request *)msg->payload;
648 req->handle = ksmbd_acquire_id(&ipc_ida);
649 strscpy(req->share_name, name, KSMBD_REQ_MAX_SHARE_NAME);
651 resp = ipc_msg_send_request(msg, req->handle);
652 ipc_msg_handle_free(req->handle);
657 struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess, int handle)
659 struct ksmbd_ipc_msg *msg;
660 struct ksmbd_rpc_command *req;
661 struct ksmbd_rpc_command *resp;
663 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
667 msg->type = KSMBD_EVENT_RPC_REQUEST;
668 req = (struct ksmbd_rpc_command *)msg->payload;
669 req->handle = handle;
670 req->flags = ksmbd_session_rpc_method(sess, handle);
671 req->flags |= KSMBD_RPC_OPEN_METHOD;
674 resp = ipc_msg_send_request(msg, req->handle);
679 struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess, int handle)
681 struct ksmbd_ipc_msg *msg;
682 struct ksmbd_rpc_command *req;
683 struct ksmbd_rpc_command *resp;
685 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
689 msg->type = KSMBD_EVENT_RPC_REQUEST;
690 req = (struct ksmbd_rpc_command *)msg->payload;
691 req->handle = handle;
692 req->flags = ksmbd_session_rpc_method(sess, handle);
693 req->flags |= KSMBD_RPC_CLOSE_METHOD;
696 resp = ipc_msg_send_request(msg, req->handle);
701 struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess, int handle,
702 void *payload, size_t payload_sz)
704 struct ksmbd_ipc_msg *msg;
705 struct ksmbd_rpc_command *req;
706 struct ksmbd_rpc_command *resp;
708 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz + 1);
712 msg->type = KSMBD_EVENT_RPC_REQUEST;
713 req = (struct ksmbd_rpc_command *)msg->payload;
714 req->handle = handle;
715 req->flags = ksmbd_session_rpc_method(sess, handle);
716 req->flags |= rpc_context_flags(sess);
717 req->flags |= KSMBD_RPC_WRITE_METHOD;
718 req->payload_sz = payload_sz;
719 memcpy(req->payload, payload, payload_sz);
721 resp = ipc_msg_send_request(msg, req->handle);
726 struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess, int handle)
728 struct ksmbd_ipc_msg *msg;
729 struct ksmbd_rpc_command *req;
730 struct ksmbd_rpc_command *resp;
732 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
736 msg->type = KSMBD_EVENT_RPC_REQUEST;
737 req = (struct ksmbd_rpc_command *)msg->payload;
738 req->handle = handle;
739 req->flags = ksmbd_session_rpc_method(sess, handle);
740 req->flags |= rpc_context_flags(sess);
741 req->flags |= KSMBD_RPC_READ_METHOD;
744 resp = ipc_msg_send_request(msg, req->handle);
749 struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess, int handle,
750 void *payload, size_t payload_sz)
752 struct ksmbd_ipc_msg *msg;
753 struct ksmbd_rpc_command *req;
754 struct ksmbd_rpc_command *resp;
756 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz + 1);
760 msg->type = KSMBD_EVENT_RPC_REQUEST;
761 req = (struct ksmbd_rpc_command *)msg->payload;
762 req->handle = handle;
763 req->flags = ksmbd_session_rpc_method(sess, handle);
764 req->flags |= rpc_context_flags(sess);
765 req->flags |= KSMBD_RPC_IOCTL_METHOD;
766 req->payload_sz = payload_sz;
767 memcpy(req->payload, payload, payload_sz);
769 resp = ipc_msg_send_request(msg, req->handle);
774 struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess, void *payload,
777 struct ksmbd_ipc_msg *msg;
778 struct ksmbd_rpc_command *req;
779 struct ksmbd_rpc_command *resp;
781 msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz + 1);
785 msg->type = KSMBD_EVENT_RPC_REQUEST;
786 req = (struct ksmbd_rpc_command *)msg->payload;
787 req->handle = ksmbd_acquire_id(&ipc_ida);
788 req->flags = rpc_context_flags(sess);
789 req->flags |= KSMBD_RPC_RAP_METHOD;
790 req->payload_sz = payload_sz;
791 memcpy(req->payload, payload, payload_sz);
793 resp = ipc_msg_send_request(msg, req->handle);
794 ipc_msg_handle_free(req->handle);
799 static int __ipc_heartbeat(void)
803 if (!ksmbd_server_running())
806 if (time_after(jiffies, server_conf.ipc_last_active)) {
807 delta = (jiffies - server_conf.ipc_last_active);
809 ipc_update_last_active();
810 schedule_delayed_work(&ipc_timer_work,
811 server_conf.ipc_timeout);
815 if (delta < server_conf.ipc_timeout) {
816 schedule_delayed_work(&ipc_timer_work,
817 server_conf.ipc_timeout - delta);
821 if (ksmbd_ipc_heartbeat_request() == 0) {
822 schedule_delayed_work(&ipc_timer_work,
823 server_conf.ipc_timeout);
827 mutex_lock(&startup_lock);
828 WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
829 server_conf.ipc_last_active = 0;
831 pr_err("No IPC daemon response for %lus\n", delta / HZ);
832 mutex_unlock(&startup_lock);
836 static void ipc_timer_heartbeat(struct work_struct *w)
838 if (__ipc_heartbeat())
839 server_queue_ctrl_reset_work();
842 int ksmbd_ipc_id_alloc(void)
844 return ksmbd_acquire_id(&ipc_ida);
847 void ksmbd_rpc_id_free(int handle)
849 ksmbd_release_id(&ipc_ida, handle);
852 void ksmbd_ipc_release(void)
854 cancel_delayed_work_sync(&ipc_timer_work);
855 genl_unregister_family(&ksmbd_genl_family);
858 void ksmbd_ipc_soft_reset(void)
860 mutex_lock(&startup_lock);
862 cancel_delayed_work_sync(&ipc_timer_work);
863 mutex_unlock(&startup_lock);
866 int ksmbd_ipc_init(void)
870 ksmbd_nl_init_fixup();
871 INIT_DELAYED_WORK(&ipc_timer_work, ipc_timer_heartbeat);
873 ret = genl_register_family(&ksmbd_genl_family);
875 pr_err("Failed to register KSMBD netlink interface %d\n", ret);
876 cancel_delayed_work_sync(&ipc_timer_work);