#include <linux/freezer.h>
#include <linux/uio.h>
#include "smb_common.h"
#include "server.h"
#include "auth.h"
#include "connection.h"
#include "transport_tcp.h"
#define IFACE_STATE_DOWN BIT(0)
#define IFACE_STATE_CONFIGURED BIT(1)
static atomic_t active_num_conn;
struct interface {
struct task_struct *ksmbd_kthread;
struct socket *ksmbd_socket;
struct list_head entry;
char *name;
int state;
};
static LIST_HEAD(iface_list);
static int bind_additional_ifaces;
struct tcp_tx {
struct list_head list;
size_t len;
size_t offset;
unsigned long deadline;
int msg_flags;
u8 data[];
};
struct tcp_transport {
struct ksmbd_transport transport;
struct socket *sock;
struct kvec *iov;
unsigned int nr_iov;
struct mutex tx_lock;
struct list_head tx_queue;
struct delayed_work tx_work;
size_t tx_queued;
u64 tx_end;
u64 tx_sent;
bool tx_stopped;
void (*write_space)(struct sock *sk);
};
static const struct ksmbd_transport_ops ksmbd_tcp_transport_ops;
static void tcp_stop_kthread(struct task_struct *kthread);
static void ksmbd_tcp_stop_listener(struct interface *iface);
static struct interface *alloc_iface(char *ifname);
static void ksmbd_tcp_disconnect(struct ksmbd_transport *t);
static void ksmbd_tcp_shutdown(struct ksmbd_transport *t);
static void ksmbd_tcp_tx_work(struct work_struct *work);
static void ksmbd_tcp_write_space(struct sock *sk);
static void ksmbd_tcp_stop_tx(struct tcp_transport *t);
#define KSMBD_TRANS(t) (&(t)->transport)
#define TCP_TRANS(t) ((struct tcp_transport *)container_of(t, \
struct tcp_transport, transport))
static inline void ksmbd_tcp_nodelay(struct socket *sock)
{
tcp_sock_set_nodelay(sock->sk);
}
static inline void ksmbd_tcp_reuseaddr(struct socket *sock)
{
sock_set_reuseaddr(sock->sk);
}
static struct tcp_transport *alloc_transport(struct socket *client_sk)
{
struct tcp_transport *t;
struct ksmbd_conn *conn;
t = kzalloc_obj(*t, KSMBD_DEFAULT_GFP);
if (!t)
return NULL;
t->sock = client_sk;
mutex_init(&t->tx_lock);
INIT_LIST_HEAD(&t->tx_queue);
INIT_DELAYED_WORK(&t->tx_work, ksmbd_tcp_tx_work);
conn = ksmbd_conn_alloc();
if (!conn) {
kfree(t);
return NULL;
}
#if IS_ENABLED(CONFIG_IPV6)
if (client_sk->sk->sk_family == AF_INET6) {
memcpy(&conn->inet6_addr, &client_sk->sk->sk_v6_daddr, 16);
conn->inet_hash = ipv6_addr_hash(&client_sk->sk->sk_v6_daddr);
conn->is_ipv6 = true;
} else {
conn->inet_addr = inet_sk(client_sk->sk)->inet_daddr;
conn->inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
}
#else
conn->inet_addr = inet_sk(client_sk->sk)->inet_daddr;
conn->inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
#endif
conn->transport = KSMBD_TRANS(t);
KSMBD_TRANS(t)->conn = conn;
KSMBD_TRANS(t)->ops = &ksmbd_tcp_transport_ops;
lock_sock(client_sk->sk);
t->tx_end = tcp_sk(client_sk->sk)->bytes_acked +
(u32)(tcp_sk(client_sk->sk)->write_seq -
tcp_sk(client_sk->sk)->snd_una);
t->tx_sent = t->tx_end;
release_sock(client_sk->sk);
write_lock_bh(&client_sk->sk->sk_callback_lock);
t->write_space = client_sk->sk->sk_write_space;
client_sk->sk->sk_user_data = t;
client_sk->sk->sk_write_space = ksmbd_tcp_write_space;
write_unlock_bh(&client_sk->sk->sk_callback_lock);
down_write(&conn_list_lock);
hash_add(conn_list, &conn->hlist, conn->inet_hash);
up_write(&conn_list_lock);
return t;
}
static void ksmbd_tcp_free_transport(struct ksmbd_transport *kt)
{
struct tcp_transport *t = TCP_TRANS(kt);
ksmbd_tcp_stop_tx(t);
sock_release(t->sock);
kfree(t->iov);
kfree(t);
}
static void free_transport(struct tcp_transport *t)
{
ksmbd_tcp_shutdown(KSMBD_TRANS(t));
ksmbd_tcp_stop_tx(t);
ksmbd_conn_free(KSMBD_TRANS(t)->conn);
}
static unsigned int kvec_array_init(struct kvec *new, struct kvec *iov,
unsigned int nr_segs, size_t bytes)
{
size_t base = 0;
while (bytes || !iov->iov_len) {
int copy = min(bytes, iov->iov_len);
bytes -= copy;
base += copy;
if (iov->iov_len == base) {
iov++;
nr_segs--;
base = 0;
}
}
memcpy(new, iov, sizeof(*iov) * nr_segs);
new->iov_base += base;
new->iov_len -= base;
return nr_segs;
}
static struct kvec *get_conn_iovec(struct tcp_transport *t, unsigned int nr_segs)
{
struct kvec *new_iov;
if (t->iov && nr_segs <= t->nr_iov)
return t->iov;
new_iov = kmalloc_objs(*new_iov, nr_segs, KSMBD_DEFAULT_GFP);
if (new_iov) {
kfree(t->iov);
t->iov = new_iov;
t->nr_iov = nr_segs;
}
return new_iov;
}
static int ksmbd_tcp_new_connection(struct socket *client_sk)
{
int rc = 0;
struct tcp_transport *t;
struct task_struct *handler;
t = alloc_transport(client_sk);
if (!t) {
sock_release(client_sk);
if (server_conf.max_connections)
atomic_dec(&active_num_conn);
return -ENOMEM;
}
#if IS_ENABLED(CONFIG_IPV6)
if (client_sk->sk->sk_family == AF_INET6)
handler = kthread_run(ksmbd_conn_handler_loop,
KSMBD_TRANS(t)->conn, "ksmbd:%pI6c",
&KSMBD_TRANS(t)->conn->inet6_addr);
else
handler = kthread_run(ksmbd_conn_handler_loop,
KSMBD_TRANS(t)->conn, "ksmbd:%pI4",
&KSMBD_TRANS(t)->conn->inet_addr);
#else
handler = kthread_run(ksmbd_conn_handler_loop,
KSMBD_TRANS(t)->conn, "ksmbd:%pI4",
&KSMBD_TRANS(t)->conn->inet_addr);
#endif
if (IS_ERR(handler)) {
pr_err("cannot start conn thread\n");
rc = PTR_ERR(handler);
ksmbd_tcp_disconnect(KSMBD_TRANS(t));
}
return rc;
}
static int ksmbd_kthread_fn(void *p)
{
struct socket *client_sk = NULL;
struct interface *iface = (struct interface *)p;
struct ksmbd_conn *conn;
int ret, inet_hash;
unsigned int max_ip_conns;
while (!kthread_should_stop()) {
if (!iface->ksmbd_socket) {
break;
}
ret = kernel_accept(iface->ksmbd_socket, &client_sk, 0);
if (ret == -EINVAL)
break;
if (ret)
continue;
if (!server_conf.max_ip_connections)
goto skip_max_ip_conns_limit;
#if IS_ENABLED(CONFIG_IPV6)
if (client_sk->sk->sk_family == AF_INET6)
inet_hash = ipv6_addr_hash(&client_sk->sk->sk_v6_daddr);
else
inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
#else
inet_hash = ipv4_addr_hash(inet_sk(client_sk->sk)->inet_daddr);
#endif
max_ip_conns = 0;
down_read(&conn_list_lock);
hash_for_each_possible(conn_list, conn, hlist, inet_hash) {
#if IS_ENABLED(CONFIG_IPV6)
if (client_sk->sk->sk_family == AF_INET6) {
if (memcmp(&client_sk->sk->sk_v6_daddr,
&conn->inet6_addr, 16) == 0)
max_ip_conns++;
} else if (inet_sk(client_sk->sk)->inet_daddr ==
conn->inet_addr)
max_ip_conns++;
#else
if (inet_sk(client_sk->sk)->inet_daddr ==
conn->inet_addr)
max_ip_conns++;
#endif
if (server_conf.max_ip_connections <= max_ip_conns) {
pr_info_ratelimited("Maximum IP connections exceeded (%u/%u)\n",
max_ip_conns, server_conf.max_ip_connections);
ret = -EAGAIN;
break;
}
}
up_read(&conn_list_lock);
if (ret == -EAGAIN) {
sock_release(client_sk);
continue;
}
skip_max_ip_conns_limit:
if (server_conf.max_connections &&
atomic_inc_return(&active_num_conn) > server_conf.max_connections) {
pr_info_ratelimited("Limit the maximum number of connections(%u)\n",
atomic_read(&active_num_conn));
atomic_dec(&active_num_conn);
sock_release(client_sk);
continue;
}
ksmbd_debug(CONN, "connect success: accepted new connection\n");
client_sk->sk->sk_rcvtimeo = KSMBD_TCP_RECV_TIMEOUT;
client_sk->sk->sk_sndtimeo = KSMBD_TCP_SEND_TIMEOUT;
sock_set_keepalive(client_sk->sk);
ksmbd_tcp_new_connection(client_sk);
}
ksmbd_debug(CONN, "releasing socket\n");
return 0;
}
static int ksmbd_tcp_run_kthread(struct interface *iface)
{
int rc;
struct task_struct *kthread;
kthread = kthread_create(ksmbd_kthread_fn, (void *)iface, "ksmbd-%s",
iface->name);
if (IS_ERR(kthread)) {
rc = PTR_ERR(kthread);
return rc;
}
get_task_struct(kthread);
iface->ksmbd_kthread = kthread;
wake_up_process(kthread);
return 0;
}
static int ksmbd_tcp_readv(struct tcp_transport *t, struct kvec *iov_orig,
unsigned int nr_segs, unsigned int to_read,
int max_retries)
{
int length = 0;
int total_read;
unsigned int segs;
struct msghdr ksmbd_msg;
struct kvec *iov;
struct ksmbd_conn *conn = KSMBD_TRANS(t)->conn;
iov = get_conn_iovec(t, nr_segs);
if (!iov)
return -ENOMEM;
ksmbd_msg.msg_control = NULL;
ksmbd_msg.msg_controllen = 0;
for (total_read = 0; to_read; total_read += length, to_read -= length) {
try_to_freeze();
if (!ksmbd_conn_alive(conn)) {
total_read = -ESHUTDOWN;
break;
}
segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
length = kernel_recvmsg(t->sock, &ksmbd_msg,
iov, segs, to_read, 0);
if (length == -EINTR) {
total_read = -ESHUTDOWN;
break;
} else if (ksmbd_conn_need_reconnect(conn)) {
total_read = -EAGAIN;
break;
} else if (length == -ERESTARTSYS || length == -EAGAIN) {
if (max_retries == 0) {
total_read = length;
break;
} else if (max_retries > 0) {
max_retries--;
}
usleep_range(1000, 2000);
length = 0;
continue;
} else if (length <= 0) {
total_read = length;
break;
}
}
return total_read;
}
static int ksmbd_tcp_read(struct ksmbd_transport *t, char *buf,
unsigned int to_read, int max_retries)
{
struct kvec iov;
iov.iov_base = buf;
iov.iov_len = to_read;
return ksmbd_tcp_readv(TCP_TRANS(t), &iov, 1, to_read, max_retries);
}
static bool ksmbd_tcp_tx_has_space(struct tcp_transport *t, size_t size)
{
size_t limit = max_t(size_t, READ_ONCE(t->sock->sk->sk_sndbuf), size);
return READ_ONCE(t->tx_queued) <= limit - size;
}
static struct tcp_tx *ksmbd_tcp_alloc_tx(const struct ksmbd_transport_write *tx,
size_t offset)
{
struct tcp_tx *msg;
struct iov_iter iter;
size_t remaining = tx->size - offset;
msg = kvmalloc_flex(*msg, data, remaining, KSMBD_DEFAULT_GFP);
if (!msg)
return NULL;
iov_iter_kvec(&iter, ITER_SOURCE, tx->iov, tx->iov_cnt, tx->size);
iov_iter_advance(&iter, offset);
if (!copy_from_iter_full(msg->data, remaining, &iter)) {
kvfree(msg);
return NULL;
}
msg->len = remaining;
msg->offset = 0;
msg->msg_flags = tx->msg_flags;
return msg;
}
static void ksmbd_tcp_purge_tx(struct tcp_transport *t)
{
struct tcp_tx *msg, *next;
list_for_each_entry_safe(msg, next, &t->tx_queue, list) {
list_del(&msg->list);
kvfree(msg);
}
WRITE_ONCE(t->tx_queued, 0);
}
static bool ksmbd_tcp_send_retry(int ret)
{
return ret == -EAGAIN || ret == -EINTR || ret == -ERESTARTSYS ||
ret == -ENOMEM;
}
static void ksmbd_tcp_tx_work(struct work_struct *work)
{
struct tcp_transport *t = container_of(to_delayed_work(work),
struct tcp_transport, tx_work);
unsigned long delay = 0;
unsigned int budget = 16;
bool failed = false;
int ret;
mutex_lock(&t->tx_lock);
while (!READ_ONCE(t->tx_stopped) && !list_empty(&t->tx_queue) && budget--) {
struct tcp_tx *msg = list_first_entry(&t->tx_queue, struct tcp_tx, list);
struct msghdr hdr = {
.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT | msg->msg_flags,
};
struct kvec iov = {
.iov_base = msg->data + msg->offset,
.iov_len = msg->len - msg->offset,
};
if (time_after_eq(jiffies, msg->deadline)) {
WRITE_ONCE(t->tx_stopped, true);
failed = true;
break;
}
ret = kernel_sendmsg(t->sock, &hdr, &iov, 1, iov.iov_len);
if (ret > 0) {
msg->offset += ret;
t->tx_sent += ret;
if (msg->offset == msg->len) {
WRITE_ONCE(t->tx_queued, t->tx_queued - msg->len);
list_del(&msg->list);
kvfree(msg);
continue;
}
} else if (!ksmbd_tcp_send_retry(ret)) {
WRITE_ONCE(t->tx_stopped, true);
failed = true;
break;
}
delay = max_t(unsigned long, 1, HZ / 10);
break;
}
if (READ_ONCE(t->tx_stopped))
ksmbd_tcp_purge_tx(t);
else if (!list_empty(&t->tx_queue))
queue_delayed_work(system_dfl_wq, &t->tx_work, delay);
mutex_unlock(&t->tx_lock);
wake_up_all(&t->transport.conn->req_running_q);
if (failed)
ksmbd_conn_abort(t->transport.conn);
}
static void ksmbd_tcp_write_space(struct sock *sk)
{
struct tcp_transport *t;
read_lock_bh(&sk->sk_callback_lock);
t = sk->sk_user_data;
if (t) {
t->write_space(sk);
if (!READ_ONCE(t->tx_stopped) && sk_stream_is_writeable(sk))
mod_delayed_work(system_dfl_wq, &t->tx_work, 0);
}
read_unlock_bh(&sk->sk_callback_lock);
}
static void ksmbd_tcp_stop_tx(struct tcp_transport *t)
{
struct sock *sk = t->sock->sk;
WRITE_ONCE(t->tx_stopped, true);
write_lock_bh(&sk->sk_callback_lock);
if (sk->sk_user_data == t) {
sk->sk_write_space = t->write_space;
sk->sk_user_data = NULL;
}
write_unlock_bh(&sk->sk_callback_lock);
cancel_delayed_work_sync(&t->tx_work);
mutex_lock(&t->tx_lock);
ksmbd_tcp_purge_tx(t);
mutex_unlock(&t->tx_lock);
wake_up_all(&t->transport.conn->req_running_q);
}
static int ksmbd_tcp_writev(struct ksmbd_transport *t,
const struct ksmbd_transport_write *tx)
{
struct tcp_transport *tt = TCP_TRANS(t);
struct sock *sk = tt->sock->sk;
struct msghdr hdr = {
.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT | tx->msg_flags,
};
struct tcp_tx *msg;
unsigned long deadline = jiffies + KSMBD_TCP_SEND_TIMEOUT;
long timeout;
int sent = 0;
for (;;) {
if (tx->msg_flags & MSG_DONTWAIT) {
if (!mutex_trylock(&tt->tx_lock))
return -EAGAIN;
} else {
mutex_lock(&tt->tx_lock);
}
if (READ_ONCE(tt->tx_stopped) || ksmbd_conn_exiting(t->conn) ||
ksmbd_conn_releasing(t->conn)) {
mutex_unlock(&tt->tx_lock);
return -EPIPE;
}
if (ksmbd_tcp_tx_has_space(tt, tx->size))
break;
mutex_unlock(&tt->tx_lock);
if (tx->msg_flags & MSG_DONTWAIT)
return -EAGAIN;
timeout = deadline - jiffies;
if (time_after_eq(jiffies, deadline) ||
!wait_event_timeout(t->conn->req_running_q,
READ_ONCE(tt->tx_stopped) ||
ksmbd_conn_exiting(t->conn) ||
ksmbd_conn_releasing(t->conn) ||
ksmbd_tcp_tx_has_space(tt, tx->size),
timeout)) {
ksmbd_conn_abort(t->conn);
return -EAGAIN;
}
}
if (list_empty(&tt->tx_queue)) {
sent = kernel_sendmsg(tt->sock, &hdr, tx->iov, tx->iov_cnt, tx->size);
if (sent > 0) {
tt->tx_sent += sent;
if (sent == tx->size)
goto accepted;
} else if (ksmbd_tcp_send_retry(sent)) {
sent = 0;
} else {
WRITE_ONCE(tt->tx_stopped, true);
mutex_unlock(&tt->tx_lock);
ksmbd_conn_abort(t->conn);
return sent ?: -EPIPE;
}
}
msg = ksmbd_tcp_alloc_tx(tx, sent);
if (!msg) {
if (sent)
WRITE_ONCE(tt->tx_stopped, true);
mutex_unlock(&tt->tx_lock);
if (sent)
ksmbd_conn_abort(t->conn);
return -ENOMEM;
}
msg->deadline = deadline;
list_add_tail(&msg->list, &tt->tx_queue);
WRITE_ONCE(tt->tx_queued, tt->tx_queued + msg->len);
queue_delayed_work(system_dfl_wq, &tt->tx_work, 0);
accepted:
tt->tx_end += tx->size;
if (tx->tracking) {
tx->tracking->end = tt->tx_end;
lock_sock(sk);
tx->tracking->retry_after =
clamp_t(unsigned long, 6UL * inet_csk(sk)->icsk_rto,
DIV_ROUND_UP(1200 * HZ, MSEC_PER_SEC), 6 * HZ);
release_sock(sk);
tx->tracking->valid = true;
}
mutex_unlock(&tt->tx_lock);
return tx->size;
}
static bool ksmbd_tcp_is_acked(struct ksmbd_transport *t,
const struct ksmbd_tx_tracking *tracking)
{
struct tcp_transport *tt = TCP_TRANS(t);
struct sock *sk = tt->sock->sk;
bool acked;
mutex_lock(&tt->tx_lock);
lock_sock(sk);
acked = tt->tx_sent >= tracking->end &&
tcp_sk(sk)->bytes_acked >= tracking->end;
release_sock(sk);
mutex_unlock(&tt->tx_lock);
return acked;
}
static void ksmbd_tcp_disconnect(struct ksmbd_transport *t)
{
free_transport(TCP_TRANS(t));
if (server_conf.max_connections)
atomic_dec(&active_num_conn);
}
static void ksmbd_tcp_shutdown(struct ksmbd_transport *t)
{
WRITE_ONCE(TCP_TRANS(t)->tx_stopped, true);
kernel_sock_shutdown(TCP_TRANS(t)->sock, SHUT_RDWR);
wake_up_all(&t->conn->req_running_q);
}
static void tcp_destroy_socket(struct socket *ksmbd_socket)
{
int ret;
if (!ksmbd_socket)
return;
ret = kernel_sock_shutdown(ksmbd_socket, SHUT_RDWR);
if (ret)
pr_err("Failed to shutdown socket: %d\n", ret);
sock_release(ksmbd_socket);
}
static int create_socket(struct interface *iface)
{
int ret;
struct sockaddr_in6 sin6;
struct sockaddr_in sin;
struct socket *ksmbd_socket;
bool ipv4 = false;
ret = sock_create_kern(current->nsproxy->net_ns, PF_INET6, SOCK_STREAM,
IPPROTO_TCP, &ksmbd_socket);
if (ret) {
if (ret != -EAFNOSUPPORT)
pr_err("Can't create socket for ipv6, fallback to ipv4: %d\n", ret);
ret = sock_create_kern(current->nsproxy->net_ns, PF_INET,
SOCK_STREAM, IPPROTO_TCP, &ksmbd_socket);
if (ret) {
pr_err("Can't create socket for ipv4: %d\n", ret);
goto out_clear;
}
sin.sin_family = PF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons(server_conf.tcp_port);
ipv4 = true;
} else {
sin6.sin6_family = PF_INET6;
sin6.sin6_addr = in6addr_any;
sin6.sin6_port = htons(server_conf.tcp_port);
lock_sock(ksmbd_socket->sk);
ksmbd_socket->sk->sk_ipv6only = false;
release_sock(ksmbd_socket->sk);
}
ksmbd_tcp_nodelay(ksmbd_socket);
ksmbd_tcp_reuseaddr(ksmbd_socket);
ret = sock_setsockopt(ksmbd_socket,
SOL_SOCKET,
SO_BINDTODEVICE,
KERNEL_SOCKPTR(iface->name),
strlen(iface->name));
if (ret != -ENODEV && ret < 0) {
pr_err("Failed to set SO_BINDTODEVICE: %d\n", ret);
goto out_error;
}
if (ipv4)
ret = kernel_bind(ksmbd_socket, (struct sockaddr_unsized *)&sin,
sizeof(sin));
else
ret = kernel_bind(ksmbd_socket, (struct sockaddr_unsized *)&sin6,
sizeof(sin6));
if (ret) {
pr_err("Failed to bind socket: %d\n", ret);
goto out_error;
}
sk_net_refcnt_upgrade(ksmbd_socket->sk);
ret = kernel_listen(ksmbd_socket, KSMBD_SOCKET_BACKLOG);
if (ret) {
pr_err("Port listen() error: %d\n", ret);
goto out_error;
}
iface->ksmbd_socket = ksmbd_socket;
ret = ksmbd_tcp_run_kthread(iface);
if (ret) {
pr_err("Can't start ksmbd main kthread: %d\n", ret);
goto out_error;
}
iface->state = IFACE_STATE_CONFIGURED;
return 0;
out_error:
tcp_destroy_socket(ksmbd_socket);
out_clear:
iface->ksmbd_socket = NULL;
return ret;
}
struct interface *ksmbd_find_netdev_name_iface_list(char *netdev_name)
{
struct interface *iface;
list_for_each_entry(iface, &iface_list, entry)
if (!strcmp(iface->name, netdev_name))
return iface;
return NULL;
}
static int ksmbd_netdev_event(struct notifier_block *nb, unsigned long event,
void *ptr)
{
struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
struct interface *iface;
int ret;
if (!net_eq(dev_net(netdev), &init_net))
return NOTIFY_DONE;
switch (event) {
case NETDEV_UP:
if (netif_is_bridge_port(netdev))
return NOTIFY_OK;
iface = ksmbd_find_netdev_name_iface_list(netdev->name);
if (iface && iface->state == IFACE_STATE_DOWN) {
ksmbd_debug(CONN, "netdev-up event: netdev(%s) is going up\n",
iface->name);
ret = create_socket(iface);
if (ret)
return NOTIFY_OK;
}
if (!iface && bind_additional_ifaces) {
iface = alloc_iface(kstrdup(netdev->name, KSMBD_DEFAULT_GFP));
if (!iface)
return NOTIFY_OK;
ksmbd_debug(CONN, "netdev-up event: netdev(%s) is going up\n",
iface->name);
ret = create_socket(iface);
if (ret)
break;
}
break;
case NETDEV_DOWN:
iface = ksmbd_find_netdev_name_iface_list(netdev->name);
if (iface && iface->state == IFACE_STATE_CONFIGURED) {
ksmbd_debug(CONN, "netdev-down event: netdev(%s) is going down\n",
iface->name);
ksmbd_tcp_stop_listener(iface);
iface->state = IFACE_STATE_DOWN;
break;
}
break;
}
return NOTIFY_DONE;
}
static struct notifier_block ksmbd_netdev_notifier = {
.notifier_call = ksmbd_netdev_event,
};
int ksmbd_tcp_init(void)
{
register_netdevice_notifier(&ksmbd_netdev_notifier);
return 0;
}
static void tcp_stop_kthread(struct task_struct *kthread)
{
int ret;
if (!kthread)
return;
ret = kthread_stop_put(kthread);
if (ret)
pr_err("failed to stop forker thread\n");
}
static void ksmbd_tcp_stop_listener(struct interface *iface)
{
if (iface->ksmbd_socket)
kernel_sock_shutdown(iface->ksmbd_socket, SHUT_RDWR);
tcp_stop_kthread(iface->ksmbd_kthread);
iface->ksmbd_kthread = NULL;
if (iface->ksmbd_socket) {
sock_release(iface->ksmbd_socket);
iface->ksmbd_socket = NULL;
}
}
void ksmbd_tcp_destroy(void)
{
struct interface *iface, *tmp;
LIST_HEAD(iface_list_to_free);
unregister_netdevice_notifier(&ksmbd_netdev_notifier);
rtnl_lock();
list_splice_init(&iface_list, &iface_list_to_free);
rtnl_unlock();
list_for_each_entry_safe(iface, tmp, &iface_list_to_free, entry) {
ksmbd_tcp_stop_listener(iface);
list_del(&iface->entry);
kfree(iface->name);
kfree(iface);
}
}
static struct interface *alloc_iface(char *ifname)
{
struct interface *iface;
if (!ifname)
return NULL;
iface = kzalloc_obj(struct interface, KSMBD_DEFAULT_GFP);
if (!iface) {
kfree(ifname);
return NULL;
}
iface->name = ifname;
iface->state = IFACE_STATE_DOWN;
list_add(&iface->entry, &iface_list);
return iface;
}
int ksmbd_tcp_set_interfaces(char *ifc_list, int ifc_list_sz)
{
int sz = 0;
if (!ifc_list_sz) {
bind_additional_ifaces = 1;
return 0;
}
while (ifc_list_sz > 0) {
if (!alloc_iface(kstrdup(ifc_list, KSMBD_DEFAULT_GFP)))
return -ENOMEM;
sz = strlen(ifc_list);
if (!sz)
break;
ifc_list += sz + 1;
ifc_list_sz -= (sz + 1);
}
bind_additional_ifaces = 0;
return 0;
}
static const struct ksmbd_transport_ops ksmbd_tcp_transport_ops = {
.read = ksmbd_tcp_read,
.writev = ksmbd_tcp_writev,
.is_acked = ksmbd_tcp_is_acked,
.disconnect = ksmbd_tcp_disconnect,
.shutdown = ksmbd_tcp_shutdown,
.free_transport = ksmbd_tcp_free_transport,
}