Commit 08700dab authored by Jakub Kicinski's avatar Jakub Kicinski Committed by David S. Miller
Browse files

net/tls: move TOE-related code to a separate file 



Move tls_hw_* functions to a new, separate source file
to avoid confusion with normal, non-TOE offload.

Signed-off-by: default avatarJakub Kicinski <jakub.kicinski@netronome.com>
Reviewed-by: default avatarJohn Hurley <john.hurley@netronome.com>
Reviewed-by: default avatarSimon Horman <simon.horman@netronome.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 16bed0e6

include/net/tls.h

+3 −0
Original line number Diff line number Diff line
@@ -308,7 +308,10 @@ struct tls_offload_context_rx { 
#define TLS_OFFLOAD_CONTEXT_SIZE_RX					\

	(sizeof(struct tls_offload_context_rx) + TLS_DRIVER_STATE_SIZE_RX)



struct tls_context *tls_ctx_create(struct sock *sk);

void tls_ctx_free(struct sock *sk, struct tls_context *ctx);

void update_sk_prot(struct sock *sk, struct tls_context *ctx);



int wait_on_pending_writer(struct sock *sk, long *timeo);

int tls_sk_query(struct sock *sk, int optname, char __user *optval,

		int __user *optlen);

include/net/tls_toe.h

+4 −0
Original line number Diff line number Diff line
@@ -69,5 +69,9 @@ struct tls_toe_device { 
	struct kref kref;

};



int tls_hw_prot(struct sock *sk);

int tls_hw_hash(struct sock *sk);

void tls_hw_unhash(struct sock *sk);



void tls_toe_register_device(struct tls_toe_device *device);

void tls_toe_unregister_device(struct tls_toe_device *device);

net/tls/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -5,6 +5,6 @@ 


obj-$(CONFIG_TLS) += tls.o



tls-y := tls_main.o tls_sw.o

tls-y := tls_main.o tls_sw.o tls_toe.o



tls-$(CONFIG_TLS_DEVICE) += tls_device.o tls_device_fallback.o

net/tls/tls_main.c

+3 −102
Original line number Diff line number Diff line
@@ -59,14 +59,12 @@ static struct proto *saved_tcpv6_prot; 
static DEFINE_MUTEX(tcpv6_prot_mutex);

static struct proto *saved_tcpv4_prot;

static DEFINE_MUTEX(tcpv4_prot_mutex);

static LIST_HEAD(device_list);

static DEFINE_SPINLOCK(device_spinlock);

static struct proto tls_prots[TLS_NUM_PROTS][TLS_NUM_CONFIG][TLS_NUM_CONFIG];

static struct proto_ops tls_sw_proto_ops;

static void build_protos(struct proto prot[TLS_NUM_CONFIG][TLS_NUM_CONFIG],

			 struct proto *base);



static void update_sk_prot(struct sock *sk, struct tls_context *ctx)

void update_sk_prot(struct sock *sk, struct tls_context *ctx)

{

	int ip_ver = sk->sk_family == AF_INET6 ? TLSV6 : TLSV4;
@@ -604,7 +602,7 @@ static int tls_setsockopt(struct sock *sk, int level, int optname, 
	return do_tls_setsockopt(sk, optname, optval, optlen);

}



static struct tls_context *create_ctx(struct sock *sk)

struct tls_context *tls_ctx_create(struct sock *sk)

{

	struct inet_connection_sock *icsk = inet_csk(sk);

	struct tls_context *ctx;
@@ -644,87 +642,6 @@ static void tls_build_proto(struct sock *sk) 
	}

}



static void tls_hw_sk_destruct(struct sock *sk)

{

	struct tls_context *ctx = tls_get_ctx(sk);

	struct inet_connection_sock *icsk = inet_csk(sk);



	ctx->sk_destruct(sk);

	/* Free ctx */

	rcu_assign_pointer(icsk->icsk_ulp_data, NULL);

	tls_ctx_free(sk, ctx);

}



static int tls_hw_prot(struct sock *sk)

{

	struct tls_toe_device *dev;

	struct tls_context *ctx;

	int rc = 0;



	spin_lock_bh(&device_spinlock);

	list_for_each_entry(dev, &device_list, dev_list) {

		if (dev->feature && dev->feature(dev)) {

			ctx = create_ctx(sk);

			if (!ctx)

				goto out;



			ctx->sk_destruct = sk->sk_destruct;

			sk->sk_destruct = tls_hw_sk_destruct;

			ctx->rx_conf = TLS_HW_RECORD;

			ctx->tx_conf = TLS_HW_RECORD;

			update_sk_prot(sk, ctx);

			rc = 1;

			break;

		}

	}

out:

	spin_unlock_bh(&device_spinlock);

	return rc;

}



static void tls_hw_unhash(struct sock *sk)

{

	struct tls_context *ctx = tls_get_ctx(sk);

	struct tls_toe_device *dev;



	spin_lock_bh(&device_spinlock);

	list_for_each_entry(dev, &device_list, dev_list) {

		if (dev->unhash) {

			kref_get(&dev->kref);

			spin_unlock_bh(&device_spinlock);

			dev->unhash(dev, sk);

			kref_put(&dev->kref, dev->release);

			spin_lock_bh(&device_spinlock);

		}

	}

	spin_unlock_bh(&device_spinlock);

	ctx->sk_proto->unhash(sk);

}



static int tls_hw_hash(struct sock *sk)

{

	struct tls_context *ctx = tls_get_ctx(sk);

	struct tls_toe_device *dev;

	int err;



	err = ctx->sk_proto->hash(sk);

	spin_lock_bh(&device_spinlock);

	list_for_each_entry(dev, &device_list, dev_list) {

		if (dev->hash) {

			kref_get(&dev->kref);

			spin_unlock_bh(&device_spinlock);

			err |= dev->hash(dev, sk);

			kref_put(&dev->kref, dev->release);

			spin_lock_bh(&device_spinlock);

		}

	}

	spin_unlock_bh(&device_spinlock);



	if (err)

		tls_hw_unhash(sk);

	return err;

}



static void build_protos(struct proto prot[TLS_NUM_CONFIG][TLS_NUM_CONFIG],

			 struct proto *base)

{
@@ -789,7 +706,7 @@ static int tls_init(struct sock *sk) 


	/* allocate tls context */

	write_lock_bh(&sk->sk_callback_lock);

	ctx = create_ctx(sk);

	ctx = tls_ctx_create(sk);

	if (!ctx) {

		rc = -ENOMEM;

		goto out;
@@ -875,22 +792,6 @@ static size_t tls_get_info_size(const struct sock *sk) 
	return size;

}



void tls_toe_register_device(struct tls_toe_device *device)

{

	spin_lock_bh(&device_spinlock);

	list_add_tail(&device->dev_list, &device_list);

	spin_unlock_bh(&device_spinlock);

}

EXPORT_SYMBOL(tls_toe_register_device);



void tls_toe_unregister_device(struct tls_toe_device *device)

{

	spin_lock_bh(&device_spinlock);

	list_del(&device->dev_list);

	spin_unlock_bh(&device_spinlock);

}

EXPORT_SYMBOL(tls_toe_unregister_device);



static struct tcp_ulp_ops tcp_tls_ulp_ops __read_mostly = {

	.name			= "tls",

	.owner			= THIS_MODULE,

net/tls/tls_toe.c

0 → 100644
+139 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2016-2017, Mellanox Technologies. All rights reserved.

 * Copyright (c) 2016-2017, Dave Watson <davejwatson@fb.com>. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */



#include <linux/list.h>

#include <linux/rcupdate.h>

#include <linux/spinlock.h>

#include <net/inet_connection_sock.h>

#include <net/tls.h>

#include <net/tls_toe.h>



static LIST_HEAD(device_list);

static DEFINE_SPINLOCK(device_spinlock);



static void tls_hw_sk_destruct(struct sock *sk)

{

	struct inet_connection_sock *icsk = inet_csk(sk);

	struct tls_context *ctx = tls_get_ctx(sk);



	ctx->sk_destruct(sk);

	/* Free ctx */

	rcu_assign_pointer(icsk->icsk_ulp_data, NULL);

	tls_ctx_free(sk, ctx);

}



int tls_hw_prot(struct sock *sk)

{

	struct tls_toe_device *dev;

	struct tls_context *ctx;

	int rc = 0;



	spin_lock_bh(&device_spinlock);

	list_for_each_entry(dev, &device_list, dev_list) {

		if (dev->feature && dev->feature(dev)) {

			ctx = tls_ctx_create(sk);

			if (!ctx)

				goto out;



			ctx->sk_destruct = sk->sk_destruct;

			sk->sk_destruct = tls_hw_sk_destruct;

			ctx->rx_conf = TLS_HW_RECORD;

			ctx->tx_conf = TLS_HW_RECORD;

			update_sk_prot(sk, ctx);

			rc = 1;

			break;

		}

	}

out:

	spin_unlock_bh(&device_spinlock);

	return rc;

}



void tls_hw_unhash(struct sock *sk)

{

	struct tls_context *ctx = tls_get_ctx(sk);

	struct tls_toe_device *dev;



	spin_lock_bh(&device_spinlock);

	list_for_each_entry(dev, &device_list, dev_list) {

		if (dev->unhash) {

			kref_get(&dev->kref);

			spin_unlock_bh(&device_spinlock);

			dev->unhash(dev, sk);

			kref_put(&dev->kref, dev->release);

			spin_lock_bh(&device_spinlock);

		}

	}

	spin_unlock_bh(&device_spinlock);

	ctx->sk_proto->unhash(sk);

}



int tls_hw_hash(struct sock *sk)

{

	struct tls_context *ctx = tls_get_ctx(sk);

	struct tls_toe_device *dev;

	int err;



	err = ctx->sk_proto->hash(sk);

	spin_lock_bh(&device_spinlock);

	list_for_each_entry(dev, &device_list, dev_list) {

		if (dev->hash) {

			kref_get(&dev->kref);

			spin_unlock_bh(&device_spinlock);

			err |= dev->hash(dev, sk);

			kref_put(&dev->kref, dev->release);

			spin_lock_bh(&device_spinlock);

		}

	}

	spin_unlock_bh(&device_spinlock);



	if (err)

		tls_hw_unhash(sk);

	return err;

}



void tls_toe_register_device(struct tls_toe_device *device)

{

	spin_lock_bh(&device_spinlock);

	list_add_tail(&device->dev_list, &device_list);

	spin_unlock_bh(&device_spinlock);

}

EXPORT_SYMBOL(tls_toe_register_device);



void tls_toe_unregister_device(struct tls_toe_device *device)

{

	spin_lock_bh(&device_spinlock);

	list_del(&device->dev_list);

	spin_unlock_bh(&device_spinlock);

}

EXPORT_SYMBOL(tls_toe_unregister_device);