1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2017, Microsoft Corporation. 4 * Copyright (C) 2018, LG Electronics. 5 * 6 * Author(s): Long Li <longli@microsoft.com>, 7 * Hyunchul Lee <hyc.lee@gmail.com> 8 */ 9 10 #define SUBMOD_NAME "smb_direct" 11 12 #include <linux/kthread.h> 13 #include <linux/list.h> 14 #include <linux/string_choices.h> 15 16 #include "glob.h" 17 #include "connection.h" 18 #include "smb_common.h" 19 #include "../common/smb2status.h" 20 #include "transport_rdma.h" 21 22 23 #define SMB_DIRECT_PORT_IWARP 5445 24 #define SMB_DIRECT_PORT_INFINIBAND 445 25 26 /* SMB_DIRECT negotiation timeout (for the server) in seconds */ 27 #define SMB_DIRECT_NEGOTIATE_TIMEOUT 5 28 29 /* The timeout to wait for a keepalive message from peer in seconds */ 30 #define SMB_DIRECT_KEEPALIVE_SEND_INTERVAL 120 31 32 /* The timeout to wait for a keepalive message from peer in seconds */ 33 #define SMB_DIRECT_KEEPALIVE_RECV_TIMEOUT 5 34 35 /* 36 * Default maximum number of RDMA read/write outstanding on this connection 37 * This value is possibly decreased during QP creation on hardware limit 38 */ 39 #define SMB_DIRECT_CM_INITIATOR_DEPTH 8 40 41 /* 42 * User configurable initial values per SMB_DIRECT transport connection 43 * as defined in [MS-SMBD] 3.1.1.1 44 * Those may change after a SMB_DIRECT negotiation 45 */ 46 47 /* The local peer's maximum number of credits to grant to the peer */ 48 static int smb_direct_receive_credit_max = 255; 49 50 /* The remote peer's credit request of local peer */ 51 static int smb_direct_send_credit_target = 255; 52 53 /* The maximum single message size can be sent to remote peer */ 54 static int smb_direct_max_send_size = 1364; 55 56 /* 57 * The maximum fragmented upper-layer payload receive size supported 58 * 59 * Assume max_payload_per_credit is 60 * smb_direct_receive_credit_max - 24 = 1340 61 * 62 * The maximum number would be 63 * smb_direct_receive_credit_max * max_payload_per_credit 64 * 65 * 1340 * 255 = 341700 (0x536C4) 66 * 67 * The minimum value from the spec is 131072 (0x20000) 68 * 69 * For now we use the logic we used before: 70 * (1364 * 255) / 2 = 173910 (0x2A756) 71 */ 72 static int smb_direct_max_fragmented_recv_size = (1364 * 255) / 2; 73 74 /* The maximum single-message size which can be received */ 75 static int smb_direct_max_receive_size = 1364; 76 77 static int smb_direct_max_read_write_size = SMBD_DEFAULT_IOSIZE; 78 79 static struct smb_direct_listener { 80 int port; 81 82 struct task_struct *thread; 83 84 struct smbdirect_socket *socket; 85 } smb_direct_ib_listener, smb_direct_iw_listener; 86 87 struct smb_direct_transport { 88 struct ksmbd_transport transport; 89 90 struct smbdirect_socket *socket; 91 }; 92 93 static bool smb_direct_logging_needed(struct smbdirect_socket *sc, 94 void *private_ptr, 95 unsigned int lvl, 96 unsigned int cls) 97 { 98 if (lvl <= SMBDIRECT_LOG_ERR) 99 return true; 100 101 if (lvl > SMBDIRECT_LOG_INFO) 102 return false; 103 104 switch (cls) { 105 /* 106 * These were more or less also logged before 107 * the move to common code. 108 * 109 * SMBDIRECT_LOG_RDMA_MR was not used, but 110 * that's client only code and we should 111 * notice if it's used on the server... 112 */ 113 case SMBDIRECT_LOG_RDMA_EVENT: 114 case SMBDIRECT_LOG_RDMA_SEND: 115 case SMBDIRECT_LOG_RDMA_RECV: 116 case SMBDIRECT_LOG_WRITE: 117 case SMBDIRECT_LOG_READ: 118 case SMBDIRECT_LOG_NEGOTIATE: 119 case SMBDIRECT_LOG_OUTGOING: 120 case SMBDIRECT_LOG_RDMA_RW: 121 case SMBDIRECT_LOG_RDMA_MR: 122 return true; 123 /* 124 * These were not logged before the move 125 * to common code. 126 */ 127 case SMBDIRECT_LOG_KEEP_ALIVE: 128 case SMBDIRECT_LOG_INCOMING: 129 return false; 130 } 131 132 /* 133 * Log all unknown messages 134 */ 135 return true; 136 } 137 138 static void smb_direct_logging_vaprintf(struct smbdirect_socket *sc, 139 const char *func, 140 unsigned int line, 141 void *private_ptr, 142 unsigned int lvl, 143 unsigned int cls, 144 struct va_format *vaf) 145 { 146 if (lvl <= SMBDIRECT_LOG_ERR) 147 pr_err("%pV", vaf); 148 else 149 ksmbd_debug(RDMA, "%pV", vaf); 150 } 151 152 #define KSMBD_TRANS(t) (&(t)->transport) 153 #define SMBD_TRANS(t) (container_of(t, \ 154 struct smb_direct_transport, transport)) 155 156 static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops; 157 158 void init_smbd_max_io_size(unsigned int sz) 159 { 160 sz = clamp_val(sz, SMBD_MIN_IOSIZE, SMBD_MAX_IOSIZE); 161 smb_direct_max_read_write_size = sz; 162 } 163 164 unsigned int get_smbd_max_read_write_size(struct ksmbd_transport *kt) 165 { 166 struct smb_direct_transport *t; 167 const struct smbdirect_socket_parameters *sp; 168 169 if (kt->ops != &ksmbd_smb_direct_transport_ops) 170 return 0; 171 172 t = SMBD_TRANS(kt); 173 sp = smbdirect_socket_get_current_parameters(t->socket); 174 175 return sp->max_read_write_size; 176 } 177 178 static struct smb_direct_transport *alloc_transport(struct smbdirect_socket *sc) 179 { 180 struct smb_direct_transport *t; 181 struct ksmbd_conn *conn; 182 183 t = kzalloc_obj(*t, KSMBD_DEFAULT_GFP); 184 if (!t) 185 return NULL; 186 t->socket = sc; 187 188 conn = ksmbd_conn_alloc(); 189 if (!conn) 190 goto conn_alloc_failed; 191 192 down_write(&conn_list_lock); 193 hash_add(conn_list, &conn->hlist, 0); 194 up_write(&conn_list_lock); 195 196 conn->transport = KSMBD_TRANS(t); 197 KSMBD_TRANS(t)->conn = conn; 198 KSMBD_TRANS(t)->ops = &ksmbd_smb_direct_transport_ops; 199 200 return t; 201 202 conn_alloc_failed: 203 kfree(t); 204 return NULL; 205 } 206 207 static void smb_direct_free_transport(struct ksmbd_transport *kt) 208 { 209 struct smb_direct_transport *t = SMBD_TRANS(kt); 210 211 smbdirect_socket_release(t->socket); 212 kfree(t); 213 } 214 215 static void free_transport(struct smb_direct_transport *t) 216 { 217 smbdirect_socket_shutdown(t->socket); 218 ksmbd_conn_free(KSMBD_TRANS(t)->conn); 219 } 220 221 static int smb_direct_read(struct ksmbd_transport *t, char *buf, 222 unsigned int size, int unused) 223 { 224 struct smb_direct_transport *st = SMBD_TRANS(t); 225 struct smbdirect_socket *sc = st->socket; 226 struct msghdr msg = { .msg_flags = 0, }; 227 struct kvec iov = { 228 .iov_base = buf, 229 .iov_len = size, 230 }; 231 int ret; 232 233 iov_iter_kvec(&msg.msg_iter, ITER_DEST, &iov, 1, size); 234 235 ret = smbdirect_connection_recvmsg(sc, &msg, 0); 236 if (ret == -ERESTARTSYS) 237 ret = -EINTR; 238 return ret; 239 } 240 241 static int smb_direct_writev(struct ksmbd_transport *t, 242 struct kvec *iov, int niovs, int buflen, 243 bool need_invalidate, unsigned int remote_key) 244 { 245 struct smb_direct_transport *st = SMBD_TRANS(t); 246 struct smbdirect_socket *sc = st->socket; 247 struct iov_iter iter; 248 249 iov_iter_kvec(&iter, ITER_SOURCE, iov, niovs, buflen); 250 251 return smbdirect_connection_send_iter(sc, &iter, 0, 252 need_invalidate, remote_key); 253 } 254 255 static int smb_direct_rdma_write(struct ksmbd_transport *t, 256 void *buf, unsigned int buflen, 257 struct smbdirect_buffer_descriptor_v1 *desc, 258 unsigned int desc_len) 259 { 260 struct smb_direct_transport *st = SMBD_TRANS(t); 261 struct smbdirect_socket *sc = st->socket; 262 263 return smbdirect_connection_rdma_xmit(sc, buf, buflen, 264 desc, desc_len, false); 265 } 266 267 static int smb_direct_rdma_read(struct ksmbd_transport *t, 268 void *buf, unsigned int buflen, 269 struct smbdirect_buffer_descriptor_v1 *desc, 270 unsigned int desc_len) 271 { 272 struct smb_direct_transport *st = SMBD_TRANS(t); 273 struct smbdirect_socket *sc = st->socket; 274 275 return smbdirect_connection_rdma_xmit(sc, buf, buflen, 276 desc, desc_len, true); 277 } 278 279 static void smb_direct_disconnect(struct ksmbd_transport *t) 280 { 281 struct smb_direct_transport *st = SMBD_TRANS(t); 282 struct smbdirect_socket *sc = st->socket; 283 284 ksmbd_debug(RDMA, "Disconnecting sc=%p\n", sc); 285 286 free_transport(st); 287 } 288 289 static void smb_direct_shutdown(struct ksmbd_transport *t) 290 { 291 struct smb_direct_transport *st = SMBD_TRANS(t); 292 struct smbdirect_socket *sc = st->socket; 293 294 ksmbd_debug(RDMA, "smb-direct shutdown sc=%p\n", sc); 295 296 smbdirect_socket_shutdown(sc); 297 } 298 299 static int smb_direct_new_connection(struct smb_direct_listener *listener, 300 struct smbdirect_socket *client_sc) 301 { 302 struct smb_direct_transport *t; 303 struct task_struct *handler; 304 int ret; 305 306 t = alloc_transport(client_sc); 307 if (!t) { 308 smbdirect_socket_release(client_sc); 309 return -ENOMEM; 310 } 311 312 handler = kthread_run(ksmbd_conn_handler_loop, 313 KSMBD_TRANS(t)->conn, "ksmbd:r%u", 314 listener->port); 315 if (IS_ERR(handler)) { 316 ret = PTR_ERR(handler); 317 pr_err("Can't start thread\n"); 318 goto out_err; 319 } 320 321 return 0; 322 out_err: 323 free_transport(t); 324 return ret; 325 } 326 327 static int smb_direct_listener_kthread_fn(void *p) 328 { 329 struct smb_direct_listener *listener = (struct smb_direct_listener *)p; 330 struct smbdirect_socket *client_sc = NULL; 331 332 while (!kthread_should_stop()) { 333 struct proto_accept_arg arg = { .err = -EINVAL, }; 334 long timeo = MAX_SCHEDULE_TIMEOUT; 335 336 if (!listener->socket) 337 break; 338 client_sc = smbdirect_socket_accept(listener->socket, timeo, &arg); 339 if (!client_sc && arg.err == -EINVAL) 340 break; 341 if (!client_sc) 342 continue; 343 344 ksmbd_debug(CONN, "connect success: accepted new connection\n"); 345 smb_direct_new_connection(listener, client_sc); 346 } 347 348 ksmbd_debug(CONN, "releasing socket\n"); 349 return 0; 350 } 351 352 static void smb_direct_listener_destroy(struct smb_direct_listener *listener) 353 { 354 int ret; 355 356 if (listener->socket) 357 smbdirect_socket_shutdown(listener->socket); 358 359 if (listener->thread) { 360 ret = kthread_stop(listener->thread); 361 if (ret) 362 pr_err("failed to stop forker thread\n"); 363 listener->thread = NULL; 364 } 365 366 if (listener->socket) { 367 smbdirect_socket_release(listener->socket); 368 listener->socket = NULL; 369 } 370 371 listener->port = 0; 372 } 373 374 static int smb_direct_listen(struct smb_direct_listener *listener, 375 int port) 376 { 377 struct net *net = current->nsproxy->net_ns; 378 struct task_struct *kthread; 379 struct sockaddr_in sin = { 380 .sin_family = AF_INET, 381 .sin_addr.s_addr = htonl(INADDR_ANY), 382 .sin_port = htons(port), 383 }; 384 struct smbdirect_socket_parameters init_params = {}; 385 struct smbdirect_socket_parameters *sp; 386 struct smbdirect_socket *sc; 387 u64 port_flags = 0; 388 int ret; 389 390 switch (port) { 391 case SMB_DIRECT_PORT_IWARP: 392 /* 393 * only allow iWarp devices 394 * for port 5445. 395 */ 396 port_flags |= SMBDIRECT_FLAG_PORT_RANGE_ONLY_IW; 397 break; 398 case SMB_DIRECT_PORT_INFINIBAND: 399 /* 400 * only allow InfiniBand, RoCEv1 or RoCEv2 401 * devices for port 445. 402 * 403 * (Basically don't allow iWarp devices) 404 */ 405 port_flags |= SMBDIRECT_FLAG_PORT_RANGE_ONLY_IB; 406 break; 407 default: 408 pr_err("unsupported smbdirect port=%d!\n", port); 409 return -ENODEV; 410 } 411 412 ret = smbdirect_socket_create_kern(net, &sc); 413 if (ret) { 414 pr_err("smbdirect_socket_create_kern() failed: %d %1pe\n", 415 ret, ERR_PTR(ret)); 416 return ret; 417 } 418 419 /* 420 * Create the initial parameters 421 */ 422 sp = &init_params; 423 sp->flags |= port_flags; 424 sp->negotiate_timeout_msec = SMB_DIRECT_NEGOTIATE_TIMEOUT * 1000; 425 sp->initiator_depth = SMB_DIRECT_CM_INITIATOR_DEPTH; 426 sp->responder_resources = 1; 427 sp->recv_credit_max = smb_direct_receive_credit_max; 428 sp->send_credit_target = smb_direct_send_credit_target; 429 sp->max_send_size = smb_direct_max_send_size; 430 sp->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size; 431 sp->max_recv_size = smb_direct_max_receive_size; 432 sp->max_read_write_size = smb_direct_max_read_write_size; 433 sp->keepalive_interval_msec = SMB_DIRECT_KEEPALIVE_SEND_INTERVAL * 1000; 434 sp->keepalive_timeout_msec = SMB_DIRECT_KEEPALIVE_RECV_TIMEOUT * 1000; 435 436 smbdirect_socket_set_logging(sc, NULL, 437 smb_direct_logging_needed, 438 smb_direct_logging_vaprintf); 439 ret = smbdirect_socket_set_initial_parameters(sc, sp); 440 if (ret) { 441 pr_err("Failed smbdirect_socket_set_initial_parameters(): %d %1pe\n", 442 ret, ERR_PTR(ret)); 443 goto err; 444 } 445 ret = smbdirect_socket_set_kernel_settings(sc, IB_POLL_WORKQUEUE, KSMBD_DEFAULT_GFP); 446 if (ret) { 447 pr_err("Failed smbdirect_socket_set_kernel_settings(): %d %1pe\n", 448 ret, ERR_PTR(ret)); 449 goto err; 450 } 451 452 ret = smbdirect_socket_bind(sc, (struct sockaddr *)&sin); 453 if (ret) { 454 pr_err("smbdirect_socket_bind() failed: %d %1pe\n", 455 ret, ERR_PTR(ret)); 456 goto err; 457 } 458 459 ret = smbdirect_socket_listen(sc, 10); 460 if (ret) { 461 pr_err("Port[%d] smbdirect_socket_listen() failed: %d %1pe\n", 462 port, ret, ERR_PTR(ret)); 463 goto err; 464 } 465 466 listener->port = port; 467 listener->socket = sc; 468 469 kthread = kthread_run(smb_direct_listener_kthread_fn, 470 listener, 471 "ksmbd-smbdirect-listener-%u", port); 472 if (IS_ERR(kthread)) { 473 ret = PTR_ERR(kthread); 474 pr_err("Can't start ksmbd listen kthread: %d %1pe\n", 475 ret, ERR_PTR(ret)); 476 goto err; 477 } 478 479 listener->thread = kthread; 480 return 0; 481 err: 482 smb_direct_listener_destroy(listener); 483 return ret; 484 } 485 486 int ksmbd_rdma_init(void) 487 { 488 int ret; 489 490 smb_direct_ib_listener = smb_direct_iw_listener = (struct smb_direct_listener) { 491 .socket = NULL, 492 }; 493 494 ret = smb_direct_listen(&smb_direct_ib_listener, 495 SMB_DIRECT_PORT_INFINIBAND); 496 if (ret) { 497 pr_err("Can't listen on InfiniBand/RoCEv1/RoCEv2: %d\n", ret); 498 goto err; 499 } 500 501 ksmbd_debug(RDMA, "InfiniBand/RoCEv1/RoCEv2 RDMA listener. socket=%p\n", 502 smb_direct_ib_listener.socket); 503 504 ret = smb_direct_listen(&smb_direct_iw_listener, 505 SMB_DIRECT_PORT_IWARP); 506 if (ret) { 507 pr_err("Can't listen on iWarp: %d\n", ret); 508 goto err; 509 } 510 511 ksmbd_debug(RDMA, "iWarp RDMA listener. socket=%p\n", 512 smb_direct_iw_listener.socket); 513 514 return 0; 515 err: 516 ksmbd_rdma_stop_listening(); 517 return ret; 518 } 519 520 void ksmbd_rdma_stop_listening(void) 521 { 522 smb_direct_listener_destroy(&smb_direct_ib_listener); 523 smb_direct_listener_destroy(&smb_direct_iw_listener); 524 } 525 526 bool ksmbd_rdma_capable_netdev(struct net_device *netdev) 527 { 528 u8 node_type = smbdirect_netdev_rdma_capable_node_type(netdev); 529 530 return node_type != RDMA_NODE_UNSPECIFIED; 531 } 532 533 static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops = { 534 .disconnect = smb_direct_disconnect, 535 .shutdown = smb_direct_shutdown, 536 .writev = smb_direct_writev, 537 .read = smb_direct_read, 538 .rdma_read = smb_direct_rdma_read, 539 .rdma_write = smb_direct_rdma_write, 540 .free_transport = smb_direct_free_transport, 541 }; 542 543 MODULE_IMPORT_NS("SMBDIRECT"); 544