fs/smb/server/transport_ipc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
   4  */
   5
   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>
  16
  17 #include "vfs_cache.h"
  18 #include "transport_ipc.h"
  19 #include "server.h"
  20 #include "smb_common.h"
  21
  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"
  30
  31 #define IPC_WAIT_TIMEOUT        (2 * HZ)
  32
  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);
  37
  38 static DEFINE_IDA(ipc_ida);
  39
  40 static unsigned int ksmbd_tools_pid;
  41
  42 static bool ksmbd_ipc_validate_version(struct genl_info *m)
  43 {
  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",
  47                        m->genlhdr->version,
  48                        KSMBD_GENL_VERSION,
  49                        "User-space ksmbd should terminate");
  50                 return false;
  51         }
  52         return true;
  53 }
  54
  55 struct ksmbd_ipc_msg {
  56         unsigned int            type;
  57         unsigned int            sz;
  58         unsigned char           payload[];
  59 };
  60
  61 struct ipc_msg_table_entry {
  62         unsigned int            handle;
  63         unsigned int            type;
  64         wait_queue_head_t       wait;
  65         struct hlist_node       ipc_table_hlist;
  66
  67         void                    *response;
  68 };
  69
  70 static struct delayed_work ipc_timer_work;
  71
  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);
  76
  77 static const struct nla_policy ksmbd_nl_policy[KSMBD_EVENT_MAX] = {
  78         [KSMBD_EVENT_UNSPEC] = {
  79                 .len = 0,
  80         },
  81         [KSMBD_EVENT_HEARTBEAT_REQUEST] = {
  82                 .len = sizeof(struct ksmbd_heartbeat),
  83         },
  84         [KSMBD_EVENT_STARTING_UP] = {
  85                 .len = sizeof(struct ksmbd_startup_request),
  86         },
  87         [KSMBD_EVENT_SHUTTING_DOWN] = {
  88                 .len = sizeof(struct ksmbd_shutdown_request),
  89         },
  90         [KSMBD_EVENT_LOGIN_REQUEST] = {
  91                 .len = sizeof(struct ksmbd_login_request),
  92         },
  93         [KSMBD_EVENT_LOGIN_RESPONSE] = {
  94                 .len = sizeof(struct ksmbd_login_response),
  95         },
  96         [KSMBD_EVENT_SHARE_CONFIG_REQUEST] = {
  97                 .len = sizeof(struct ksmbd_share_config_request),
  98         },
  99         [KSMBD_EVENT_SHARE_CONFIG_RESPONSE] = {
 100                 .len = sizeof(struct ksmbd_share_config_response),
 101         },
 102         [KSMBD_EVENT_TREE_CONNECT_REQUEST] = {
 103                 .len = sizeof(struct ksmbd_tree_connect_request),
 104         },
 105         [KSMBD_EVENT_TREE_CONNECT_RESPONSE] = {
 106                 .len = sizeof(struct ksmbd_tree_connect_response),
 107         },
 108         [KSMBD_EVENT_TREE_DISCONNECT_REQUEST] = {
 109                 .len = sizeof(struct ksmbd_tree_disconnect_request),
 110         },
 111         [KSMBD_EVENT_LOGOUT_REQUEST] = {
 112                 .len = sizeof(struct ksmbd_logout_request),
 113         },
 114         [KSMBD_EVENT_RPC_REQUEST] = {
 115         },
 116         [KSMBD_EVENT_RPC_RESPONSE] = {
 117         },
 118         [KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST] = {
 119         },
 120         [KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE] = {
 121         },
 122 };
 123
 124 static struct genl_ops ksmbd_genl_ops[] = {
 125         {
 126                 .cmd    = KSMBD_EVENT_UNSPEC,
 127                 .doit   = handle_unsupported_event,
 128         },
 129         {
 130                 .cmd    = KSMBD_EVENT_HEARTBEAT_REQUEST,
 131                 .doit   = handle_unsupported_event,
 132         },
 133         {
 134                 .cmd    = KSMBD_EVENT_STARTING_UP,
 135                 .doit   = handle_startup_event,
 136         },
 137         {
 138                 .cmd    = KSMBD_EVENT_SHUTTING_DOWN,
 139                 .doit   = handle_unsupported_event,
 140         },
 141         {
 142                 .cmd    = KSMBD_EVENT_LOGIN_REQUEST,
 143                 .doit   = handle_unsupported_event,
 144         },
 145         {
 146                 .cmd    = KSMBD_EVENT_LOGIN_RESPONSE,
 147                 .doit   = handle_generic_event,
 148         },
 149         {
 150                 .cmd    = KSMBD_EVENT_SHARE_CONFIG_REQUEST,
 151                 .doit   = handle_unsupported_event,
 152         },
 153         {
 154                 .cmd    = KSMBD_EVENT_SHARE_CONFIG_RESPONSE,
 155                 .doit   = handle_generic_event,
 156         },
 157         {
 158                 .cmd    = KSMBD_EVENT_TREE_CONNECT_REQUEST,
 159                 .doit   = handle_unsupported_event,
 160         },
 161         {
 162                 .cmd    = KSMBD_EVENT_TREE_CONNECT_RESPONSE,
 163                 .doit   = handle_generic_event,
 164         },
 165         {
 166                 .cmd    = KSMBD_EVENT_TREE_DISCONNECT_REQUEST,
 167                 .doit   = handle_unsupported_event,
 168         },
 169         {
 170                 .cmd    = KSMBD_EVENT_LOGOUT_REQUEST,
 171                 .doit   = handle_unsupported_event,
 172         },
 173         {
 174                 .cmd    = KSMBD_EVENT_RPC_REQUEST,
 175                 .doit   = handle_unsupported_event,
 176         },
 177         {
 178                 .cmd    = KSMBD_EVENT_RPC_RESPONSE,
 179                 .doit   = handle_generic_event,
 180         },
 181         {
 182                 .cmd    = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST,
 183                 .doit   = handle_unsupported_event,
 184         },
 185         {
 186                 .cmd    = KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE,
 187                 .doit   = handle_generic_event,
 188         },
 189 };
 190
 191 static struct genl_family ksmbd_genl_family = {
 192         .name           = KSMBD_GENL_NAME,
 193         .version        = KSMBD_GENL_VERSION,
 194         .hdrsize        = 0,
 195         .maxattr        = KSMBD_EVENT_MAX,
 196         .netnsok        = true,
 197         .module         = THIS_MODULE,
 198         .ops            = ksmbd_genl_ops,
 199         .n_ops          = ARRAY_SIZE(ksmbd_genl_ops),
 200         .resv_start_op  = KSMBD_EVENT_SPNEGO_AUTHEN_RESPONSE + 1,
 201 };
 202
 203 static void ksmbd_nl_init_fixup(void)
 204 {
 205         int i;
 206
 207         for (i = 0; i < ARRAY_SIZE(ksmbd_genl_ops); i++)
 208                 ksmbd_genl_ops[i].validate = GENL_DONT_VALIDATE_STRICT |
 209                                                 GENL_DONT_VALIDATE_DUMP;
 210
 211         ksmbd_genl_family.policy = ksmbd_nl_policy;
 212 }
 213
 214 static int rpc_context_flags(struct ksmbd_session *sess)
 215 {
 216         if (user_guest(sess->user))
 217                 return KSMBD_RPC_RESTRICTED_CONTEXT;
 218         return 0;
 219 }
 220
 221 static void ipc_update_last_active(void)
 222 {
 223         if (server_conf.ipc_timeout)
 224                 server_conf.ipc_last_active = jiffies;
 225 }
 226
 227 static struct ksmbd_ipc_msg *ipc_msg_alloc(size_t sz)
 228 {
 229         struct ksmbd_ipc_msg *msg;
 230         size_t msg_sz = sz + sizeof(struct ksmbd_ipc_msg);
 231
 232         msg = kvmalloc(msg_sz, GFP_KERNEL | __GFP_ZERO);
 233         if (msg)
 234                 msg->sz = sz;
 235         return msg;
 236 }
 237
 238 static void ipc_msg_free(struct ksmbd_ipc_msg *msg)
 239 {
 240         kvfree(msg);
 241 }
 242
 243 static void ipc_msg_handle_free(int handle)
 244 {
 245         if (handle >= 0)
 246                 ksmbd_release_id(&ipc_ida, handle);
 247 }
 248
 249 static int handle_response(int type, void *payload, size_t sz)
 250 {
 251         unsigned int handle = *(unsigned int *)payload;
 252         struct ipc_msg_table_entry *entry;
 253         int ret = 0;
 254
 255         ipc_update_last_active();
 256         down_read(&ipc_msg_table_lock);
 257         hash_for_each_possible(ipc_msg_table, entry, ipc_table_hlist, handle) {
 258                 if (handle != entry->handle)
 259                         continue;
 260
 261                 entry->response = NULL;
 262                 /*
 263                  * Response message type value should be equal to
 264                  * request message type + 1.
 265                  */
 266                 if (entry->type + 1 != type) {
 267                         pr_err("Waiting for IPC type %d, got %d. Ignore.\n",
 268                                entry->type + 1, type);
 269                 }
 270
 271                 entry->response = kvmalloc(sz, GFP_KERNEL | __GFP_ZERO);
 272                 if (!entry->response) {
 273                         ret = -ENOMEM;
 274                         break;
 275                 }
 276
 277                 memcpy(entry->response, payload, sz);
 278                 wake_up_interruptible(&entry->wait);
 279                 ret = 0;
 280                 break;
 281         }
 282         up_read(&ipc_msg_table_lock);
 283
 284         return ret;
 285 }
 286
 287 static int ipc_server_config_on_startup(struct ksmbd_startup_request *req)
 288 {
 289         int ret;
 290
 291         ksmbd_set_fd_limit(req->file_max);
 292         server_conf.flags = req->flags;
 293         server_conf.signing = req->signing;
 294         server_conf.tcp_port = req->tcp_port;
 295         server_conf.ipc_timeout = req->ipc_timeout * HZ;
 296         server_conf.deadtime = req->deadtime * SMB_ECHO_INTERVAL;
 297         server_conf.share_fake_fscaps = req->share_fake_fscaps;
 298         ksmbd_init_domain(req->sub_auth);
 299
 300         if (req->smb2_max_read)
 301                 init_smb2_max_read_size(req->smb2_max_read);
 302         if (req->smb2_max_write)
 303                 init_smb2_max_write_size(req->smb2_max_write);
 304         if (req->smb2_max_trans)
 305                 init_smb2_max_trans_size(req->smb2_max_trans);
 306         if (req->smb2_max_credits)
 307                 init_smb2_max_credits(req->smb2_max_credits);
 308         if (req->smbd_max_io_size)
 309                 init_smbd_max_io_size(req->smbd_max_io_size);
 310
 311         if (req->max_connections)
 312                 server_conf.max_connections = req->max_connections;
 313
 314         ret = ksmbd_set_netbios_name(req->netbios_name);
 315         ret |= ksmbd_set_server_string(req->server_string);
 316         ret |= ksmbd_set_work_group(req->work_group);
 317         ret |= ksmbd_tcp_set_interfaces(KSMBD_STARTUP_CONFIG_INTERFACES(req),
 318                                         req->ifc_list_sz);
 319         if (ret) {
 320                 pr_err("Server configuration error: %s %s %s\n",
 321                        req->netbios_name, req->server_string,
 322                        req->work_group);
 323                 return ret;
 324         }
 325
 326         if (req->min_prot[0]) {
 327                 ret = ksmbd_lookup_protocol_idx(req->min_prot);
 328                 if (ret >= 0)
 329                         server_conf.min_protocol = ret;
 330         }
 331         if (req->max_prot[0]) {
 332                 ret = ksmbd_lookup_protocol_idx(req->max_prot);
 333                 if (ret >= 0)
 334                         server_conf.max_protocol = ret;
 335         }
 336
 337         if (server_conf.ipc_timeout)
 338                 schedule_delayed_work(&ipc_timer_work, server_conf.ipc_timeout);
 339         return 0;
 340 }
 341
 342 static int handle_startup_event(struct sk_buff *skb, struct genl_info *info)
 343 {
 344         int ret = 0;
 345
 346 #ifdef CONFIG_SMB_SERVER_CHECK_CAP_NET_ADMIN
 347         if (!netlink_capable(skb, CAP_NET_ADMIN))
 348                 return -EPERM;
 349 #endif
 350
 351         if (!ksmbd_ipc_validate_version(info))
 352                 return -EINVAL;
 353
 354         if (!info->attrs[KSMBD_EVENT_STARTING_UP])
 355                 return -EINVAL;
 356
 357         mutex_lock(&startup_lock);
 358         if (!ksmbd_server_configurable()) {
 359                 mutex_unlock(&startup_lock);
 360                 pr_err("Server reset is in progress, can't start daemon\n");
 361                 return -EINVAL;
 362         }
 363
 364         if (ksmbd_tools_pid) {
 365                 if (ksmbd_ipc_heartbeat_request() == 0) {
 366                         ret = -EINVAL;
 367                         goto out;
 368                 }
 369
 370                 pr_err("Reconnect to a new user space daemon\n");
 371         } else {
 372                 struct ksmbd_startup_request *req;
 373
 374                 req = nla_data(info->attrs[info->genlhdr->cmd]);
 375                 ret = ipc_server_config_on_startup(req);
 376                 if (ret)
 377                         goto out;
 378                 server_queue_ctrl_init_work();
 379         }
 380
 381         ksmbd_tools_pid = info->snd_portid;
 382         ipc_update_last_active();
 383
 384 out:
 385         mutex_unlock(&startup_lock);
 386         return ret;
 387 }
 388
 389 static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info)
 390 {
 391         pr_err("Unknown IPC event: %d, ignore.\n", info->genlhdr->cmd);
 392         return -EINVAL;
 393 }
 394
 395 static int handle_generic_event(struct sk_buff *skb, struct genl_info *info)
 396 {
 397         void *payload;
 398         int sz;
 399         int type = info->genlhdr->cmd;
 400
 401 #ifdef CONFIG_SMB_SERVER_CHECK_CAP_NET_ADMIN
 402         if (!netlink_capable(skb, CAP_NET_ADMIN))
 403                 return -EPERM;
 404 #endif
 405
 406         if (type >= KSMBD_EVENT_MAX) {
 407                 WARN_ON(1);
 408                 return -EINVAL;
 409         }
 410
 411         if (!ksmbd_ipc_validate_version(info))
 412                 return -EINVAL;
 413
 414         if (!info->attrs[type])
 415                 return -EINVAL;
 416
 417         payload = nla_data(info->attrs[info->genlhdr->cmd]);
 418         sz = nla_len(info->attrs[info->genlhdr->cmd]);
 419         return handle_response(type, payload, sz);
 420 }
 421
 422 static int ipc_msg_send(struct ksmbd_ipc_msg *msg)
 423 {
 424         struct genlmsghdr *nlh;
 425         struct sk_buff *skb;
 426         int ret = -EINVAL;
 427
 428         if (!ksmbd_tools_pid)
 429                 return ret;
 430
 431         skb = genlmsg_new(msg->sz, GFP_KERNEL);
 432         if (!skb)
 433                 return -ENOMEM;
 434
 435         nlh = genlmsg_put(skb, 0, 0, &ksmbd_genl_family, 0, msg->type);
 436         if (!nlh)
 437                 goto out;
 438
 439         ret = nla_put(skb, msg->type, msg->sz, msg->payload);
 440         if (ret) {
 441                 genlmsg_cancel(skb, nlh);
 442                 goto out;
 443         }
 444
 445         genlmsg_end(skb, nlh);
 446         ret = genlmsg_unicast(&init_net, skb, ksmbd_tools_pid);
 447         if (!ret)
 448                 ipc_update_last_active();
 449         return ret;
 450
 451 out:
 452         nlmsg_free(skb);
 453         return ret;
 454 }
 455
 456 static void *ipc_msg_send_request(struct ksmbd_ipc_msg *msg, unsigned int handle)
 457 {
 458         struct ipc_msg_table_entry entry;
 459         int ret;
 460
 461         if ((int)handle < 0)
 462                 return NULL;
 463
 464         entry.type = msg->type;
 465         entry.response = NULL;
 466         init_waitqueue_head(&entry.wait);
 467
 468         down_write(&ipc_msg_table_lock);
 469         entry.handle = handle;
 470         hash_add(ipc_msg_table, &entry.ipc_table_hlist, entry.handle);
 471         up_write(&ipc_msg_table_lock);
 472
 473         ret = ipc_msg_send(msg);
 474         if (ret)
 475                 goto out;
 476
 477         ret = wait_event_interruptible_timeout(entry.wait,
 478                                                entry.response != NULL,
 479                                                IPC_WAIT_TIMEOUT);
 480 out:
 481         down_write(&ipc_msg_table_lock);
 482         hash_del(&entry.ipc_table_hlist);
 483         up_write(&ipc_msg_table_lock);
 484         return entry.response;
 485 }
 486
 487 static int ksmbd_ipc_heartbeat_request(void)
 488 {
 489         struct ksmbd_ipc_msg *msg;
 490         int ret;
 491
 492         msg = ipc_msg_alloc(sizeof(struct ksmbd_heartbeat));
 493         if (!msg)
 494                 return -EINVAL;
 495
 496         msg->type = KSMBD_EVENT_HEARTBEAT_REQUEST;
 497         ret = ipc_msg_send(msg);
 498         ipc_msg_free(msg);
 499         return ret;
 500 }
 501
 502 struct ksmbd_login_response *ksmbd_ipc_login_request(const char *account)
 503 {
 504         struct ksmbd_ipc_msg *msg;
 505         struct ksmbd_login_request *req;
 506         struct ksmbd_login_response *resp;
 507
 508         if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
 509                 return NULL;
 510
 511         msg = ipc_msg_alloc(sizeof(struct ksmbd_login_request));
 512         if (!msg)
 513                 return NULL;
 514
 515         msg->type = KSMBD_EVENT_LOGIN_REQUEST;
 516         req = (struct ksmbd_login_request *)msg->payload;
 517         req->handle = ksmbd_acquire_id(&ipc_ida);
 518         strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
 519
 520         resp = ipc_msg_send_request(msg, req->handle);
 521         ipc_msg_handle_free(req->handle);
 522         ipc_msg_free(msg);
 523         return resp;
 524 }
 525
 526 struct ksmbd_spnego_authen_response *
 527 ksmbd_ipc_spnego_authen_request(const char *spnego_blob, int blob_len)
 528 {
 529         struct ksmbd_ipc_msg *msg;
 530         struct ksmbd_spnego_authen_request *req;
 531         struct ksmbd_spnego_authen_response *resp;
 532
 533         msg = ipc_msg_alloc(sizeof(struct ksmbd_spnego_authen_request) +
 534                         blob_len + 1);
 535         if (!msg)
 536                 return NULL;
 537
 538         msg->type = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST;
 539         req = (struct ksmbd_spnego_authen_request *)msg->payload;
 540         req->handle = ksmbd_acquire_id(&ipc_ida);
 541         req->spnego_blob_len = blob_len;
 542         memcpy(req->spnego_blob, spnego_blob, blob_len);
 543
 544         resp = ipc_msg_send_request(msg, req->handle);
 545         ipc_msg_handle_free(req->handle);
 546         ipc_msg_free(msg);
 547         return resp;
 548 }
 549
 550 struct ksmbd_tree_connect_response *
 551 ksmbd_ipc_tree_connect_request(struct ksmbd_session *sess,
 552                                struct ksmbd_share_config *share,
 553                                struct ksmbd_tree_connect *tree_conn,
 554                                struct sockaddr *peer_addr)
 555 {
 556         struct ksmbd_ipc_msg *msg;
 557         struct ksmbd_tree_connect_request *req;
 558         struct ksmbd_tree_connect_response *resp;
 559
 560         if (strlen(user_name(sess->user)) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
 561                 return NULL;
 562
 563         if (strlen(share->name) >= KSMBD_REQ_MAX_SHARE_NAME)
 564                 return NULL;
 565
 566         msg = ipc_msg_alloc(sizeof(struct ksmbd_tree_connect_request));
 567         if (!msg)
 568                 return NULL;
 569
 570         msg->type = KSMBD_EVENT_TREE_CONNECT_REQUEST;
 571         req = (struct ksmbd_tree_connect_request *)msg->payload;
 572
 573         req->handle = ksmbd_acquire_id(&ipc_ida);
 574         req->account_flags = sess->user->flags;
 575         req->session_id = sess->id;
 576         req->connect_id = tree_conn->id;
 577         strscpy(req->account, user_name(sess->user), KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
 578         strscpy(req->share, share->name, KSMBD_REQ_MAX_SHARE_NAME);
 579         snprintf(req->peer_addr, sizeof(req->peer_addr), "%pIS", peer_addr);
 580
 581         if (peer_addr->sa_family == AF_INET6)
 582                 req->flags |= KSMBD_TREE_CONN_FLAG_REQUEST_IPV6;
 583         if (test_session_flag(sess, CIFDS_SESSION_FLAG_SMB2))
 584                 req->flags |= KSMBD_TREE_CONN_FLAG_REQUEST_SMB2;
 585
 586         resp = ipc_msg_send_request(msg, req->handle);
 587         ipc_msg_handle_free(req->handle);
 588         ipc_msg_free(msg);
 589         return resp;
 590 }
 591
 592 int ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,
 593                                       unsigned long long connect_id)
 594 {
 595         struct ksmbd_ipc_msg *msg;
 596         struct ksmbd_tree_disconnect_request *req;
 597         int ret;
 598
 599         msg = ipc_msg_alloc(sizeof(struct ksmbd_tree_disconnect_request));
 600         if (!msg)
 601                 return -ENOMEM;
 602
 603         msg->type = KSMBD_EVENT_TREE_DISCONNECT_REQUEST;
 604         req = (struct ksmbd_tree_disconnect_request *)msg->payload;
 605         req->session_id = session_id;
 606         req->connect_id = connect_id;
 607
 608         ret = ipc_msg_send(msg);
 609         ipc_msg_free(msg);
 610         return ret;
 611 }
 612
 613 int ksmbd_ipc_logout_request(const char *account, int flags)
 614 {
 615         struct ksmbd_ipc_msg *msg;
 616         struct ksmbd_logout_request *req;
 617         int ret;
 618
 619         if (strlen(account) >= KSMBD_REQ_MAX_ACCOUNT_NAME_SZ)
 620                 return -EINVAL;
 621
 622         msg = ipc_msg_alloc(sizeof(struct ksmbd_logout_request));
 623         if (!msg)
 624                 return -ENOMEM;
 625
 626         msg->type = KSMBD_EVENT_LOGOUT_REQUEST;
 627         req = (struct ksmbd_logout_request *)msg->payload;
 628         req->account_flags = flags;
 629         strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
 630
 631         ret = ipc_msg_send(msg);
 632         ipc_msg_free(msg);
 633         return ret;
 634 }
 635
 636 struct ksmbd_share_config_response *
 637 ksmbd_ipc_share_config_request(const char *name)
 638 {
 639         struct ksmbd_ipc_msg *msg;
 640         struct ksmbd_share_config_request *req;
 641         struct ksmbd_share_config_response *resp;
 642
 643         if (strlen(name) >= KSMBD_REQ_MAX_SHARE_NAME)
 644                 return NULL;
 645
 646         msg = ipc_msg_alloc(sizeof(struct ksmbd_share_config_request));
 647         if (!msg)
 648                 return NULL;
 649
 650         msg->type = KSMBD_EVENT_SHARE_CONFIG_REQUEST;
 651         req = (struct ksmbd_share_config_request *)msg->payload;
 652         req->handle = ksmbd_acquire_id(&ipc_ida);
 653         strscpy(req->share_name, name, KSMBD_REQ_MAX_SHARE_NAME);
 654
 655         resp = ipc_msg_send_request(msg, req->handle);
 656         ipc_msg_handle_free(req->handle);
 657         ipc_msg_free(msg);
 658         return resp;
 659 }
 660
 661 struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess, int handle)
 662 {
 663         struct ksmbd_ipc_msg *msg;
 664         struct ksmbd_rpc_command *req;
 665         struct ksmbd_rpc_command *resp;
 666
 667         msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
 668         if (!msg)
 669                 return NULL;
 670
 671         msg->type = KSMBD_EVENT_RPC_REQUEST;
 672         req = (struct ksmbd_rpc_command *)msg->payload;
 673         req->handle = handle;
 674         req->flags = ksmbd_session_rpc_method(sess, handle);
 675         req->flags |= KSMBD_RPC_OPEN_METHOD;
 676         req->payload_sz = 0;
 677
 678         resp = ipc_msg_send_request(msg, req->handle);
 679         ipc_msg_free(msg);
 680         return resp;
 681 }
 682
 683 struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess, int handle)
 684 {
 685         struct ksmbd_ipc_msg *msg;
 686         struct ksmbd_rpc_command *req;
 687         struct ksmbd_rpc_command *resp;
 688
 689         msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
 690         if (!msg)
 691                 return NULL;
 692
 693         msg->type = KSMBD_EVENT_RPC_REQUEST;
 694         req = (struct ksmbd_rpc_command *)msg->payload;
 695         req->handle = handle;
 696         req->flags = ksmbd_session_rpc_method(sess, handle);
 697         req->flags |= KSMBD_RPC_CLOSE_METHOD;
 698         req->payload_sz = 0;
 699
 700         resp = ipc_msg_send_request(msg, req->handle);
 701         ipc_msg_free(msg);
 702         return resp;
 703 }
 704
 705 struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess, int handle,
 706                                           void *payload, size_t payload_sz)
 707 {
 708         struct ksmbd_ipc_msg *msg;
 709         struct ksmbd_rpc_command *req;
 710         struct ksmbd_rpc_command *resp;
 711
 712         msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz + 1);
 713         if (!msg)
 714                 return NULL;
 715
 716         msg->type = KSMBD_EVENT_RPC_REQUEST;
 717         req = (struct ksmbd_rpc_command *)msg->payload;
 718         req->handle = handle;
 719         req->flags = ksmbd_session_rpc_method(sess, handle);
 720         req->flags |= rpc_context_flags(sess);
 721         req->flags |= KSMBD_RPC_WRITE_METHOD;
 722         req->payload_sz = payload_sz;
 723         memcpy(req->payload, payload, payload_sz);
 724
 725         resp = ipc_msg_send_request(msg, req->handle);
 726         ipc_msg_free(msg);
 727         return resp;
 728 }
 729
 730 struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess, int handle)
 731 {
 732         struct ksmbd_ipc_msg *msg;
 733         struct ksmbd_rpc_command *req;
 734         struct ksmbd_rpc_command *resp;
 735
 736         msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command));
 737         if (!msg)
 738                 return NULL;
 739
 740         msg->type = KSMBD_EVENT_RPC_REQUEST;
 741         req = (struct ksmbd_rpc_command *)msg->payload;
 742         req->handle = handle;
 743         req->flags = ksmbd_session_rpc_method(sess, handle);
 744         req->flags |= rpc_context_flags(sess);
 745         req->flags |= KSMBD_RPC_READ_METHOD;
 746         req->payload_sz = 0;
 747
 748         resp = ipc_msg_send_request(msg, req->handle);
 749         ipc_msg_free(msg);
 750         return resp;
 751 }
 752
 753 struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess, int handle,
 754                                           void *payload, size_t payload_sz)
 755 {
 756         struct ksmbd_ipc_msg *msg;
 757         struct ksmbd_rpc_command *req;
 758         struct ksmbd_rpc_command *resp;
 759
 760         msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz + 1);
 761         if (!msg)
 762                 return NULL;
 763
 764         msg->type = KSMBD_EVENT_RPC_REQUEST;
 765         req = (struct ksmbd_rpc_command *)msg->payload;
 766         req->handle = handle;
 767         req->flags = ksmbd_session_rpc_method(sess, handle);
 768         req->flags |= rpc_context_flags(sess);
 769         req->flags |= KSMBD_RPC_IOCTL_METHOD;
 770         req->payload_sz = payload_sz;
 771         memcpy(req->payload, payload, payload_sz);
 772
 773         resp = ipc_msg_send_request(msg, req->handle);
 774         ipc_msg_free(msg);
 775         return resp;
 776 }
 777
 778 struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess, void *payload,
 779                                         size_t payload_sz)
 780 {
 781         struct ksmbd_ipc_msg *msg;
 782         struct ksmbd_rpc_command *req;
 783         struct ksmbd_rpc_command *resp;
 784
 785         msg = ipc_msg_alloc(sizeof(struct ksmbd_rpc_command) + payload_sz + 1);
 786         if (!msg)
 787                 return NULL;
 788
 789         msg->type = KSMBD_EVENT_RPC_REQUEST;
 790         req = (struct ksmbd_rpc_command *)msg->payload;
 791         req->handle = ksmbd_acquire_id(&ipc_ida);
 792         req->flags = rpc_context_flags(sess);
 793         req->flags |= KSMBD_RPC_RAP_METHOD;
 794         req->payload_sz = payload_sz;
 795         memcpy(req->payload, payload, payload_sz);
 796
 797         resp = ipc_msg_send_request(msg, req->handle);
 798         ipc_msg_handle_free(req->handle);
 799         ipc_msg_free(msg);
 800         return resp;
 801 }
 802
 803 static int __ipc_heartbeat(void)
 804 {
 805         unsigned long delta;
 806
 807         if (!ksmbd_server_running())
 808                 return 0;
 809
 810         if (time_after(jiffies, server_conf.ipc_last_active)) {
 811                 delta = (jiffies - server_conf.ipc_last_active);
 812         } else {
 813                 ipc_update_last_active();
 814                 schedule_delayed_work(&ipc_timer_work,
 815                                       server_conf.ipc_timeout);
 816                 return 0;
 817         }
 818
 819         if (delta < server_conf.ipc_timeout) {
 820                 schedule_delayed_work(&ipc_timer_work,
 821                                       server_conf.ipc_timeout - delta);
 822                 return 0;
 823         }
 824
 825         if (ksmbd_ipc_heartbeat_request() == 0) {
 826                 schedule_delayed_work(&ipc_timer_work,
 827                                       server_conf.ipc_timeout);
 828                 return 0;
 829         }
 830
 831         mutex_lock(&startup_lock);
 832         WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
 833         server_conf.ipc_last_active = 0;
 834         ksmbd_tools_pid = 0;
 835         pr_err("No IPC daemon response for %lus\n", delta / HZ);
 836         mutex_unlock(&startup_lock);
 837         return -EINVAL;
 838 }
 839
 840 static void ipc_timer_heartbeat(struct work_struct *w)
 841 {
 842         if (__ipc_heartbeat())
 843                 server_queue_ctrl_reset_work();
 844 }
 845
 846 int ksmbd_ipc_id_alloc(void)
 847 {
 848         return ksmbd_acquire_id(&ipc_ida);
 849 }
 850
 851 void ksmbd_rpc_id_free(int handle)
 852 {
 853         ksmbd_release_id(&ipc_ida, handle);
 854 }
 855
 856 void ksmbd_ipc_release(void)
 857 {
 858         cancel_delayed_work_sync(&ipc_timer_work);
 859         genl_unregister_family(&ksmbd_genl_family);
 860 }
 861
 862 void ksmbd_ipc_soft_reset(void)
 863 {
 864         mutex_lock(&startup_lock);
 865         ksmbd_tools_pid = 0;
 866         cancel_delayed_work_sync(&ipc_timer_work);
 867         mutex_unlock(&startup_lock);
 868 }
 869
 870 int ksmbd_ipc_init(void)
 871 {
 872         int ret = 0;
 873
 874         ksmbd_nl_init_fixup();
 875         INIT_DELAYED_WORK(&ipc_timer_work, ipc_timer_heartbeat);
 876
 877         ret = genl_register_family(&ksmbd_genl_family);
 878         if (ret) {
 879                 pr_err("Failed to register KSMBD netlink interface %d\n", ret);
 880                 cancel_delayed_work_sync(&ipc_timer_work);
 881         }
 882
 883         return ret;
 884 }