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