caif_socket.c 30.4 KB
Newer Older
1 2 3 4 5 6
/*
 * Copyright (C) ST-Ericsson AB 2010
 * Author:	Sjur Brendeland sjur.brandeland@stericsson.com
 * License terms: GNU General Public License (GPL) version 2
 */

Joe Perches's avatar
Joe Perches committed
7 8
#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__

9 10 11 12 13 14 15 16 17 18 19
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/tcp.h>
#include <linux/uaccess.h>
20 21
#include <linux/mutex.h>
#include <linux/debugfs.h>
22
#include <linux/caif/caif_socket.h>
23 24 25
#include <asm/atomic.h>
#include <net/sock.h>
#include <net/tcp_states.h>
26 27 28 29 30
#include <net/caif/caif_layer.h>
#include <net/caif/caif_dev.h>
#include <net/caif/cfpkt.h>

MODULE_LICENSE("GPL");
31 32
MODULE_ALIAS_NETPROTO(AF_CAIF);

33 34
#define CAIF_DEF_SNDBUF (4096*10)
#define CAIF_DEF_RCVBUF (4096*100)
35 36 37 38 39 40 41 42 43 44 45 46 47 48

/*
 * CAIF state is re-using the TCP socket states.
 * caif_states stored in sk_state reflect the state as reported by
 * the CAIF stack, while sk_socket->state is the state of the socket.
 */
enum caif_states {
	CAIF_CONNECTED		= TCP_ESTABLISHED,
	CAIF_CONNECTING	= TCP_SYN_SENT,
	CAIF_DISCONNECTED	= TCP_CLOSE
};

#define TX_FLOW_ON_BIT	1
#define RX_FLOW_ON_BIT	2
49 50 51 52 53

static struct dentry *debugfsdir;

#ifdef CONFIG_DEBUG_FS
struct debug_fs_counter {
54 55 56 57 58
	atomic_t caif_nr_socks;
	atomic_t num_connect_req;
	atomic_t num_connect_resp;
	atomic_t num_connect_fail_resp;
	atomic_t num_disconnect;
59 60 61 62 63 64
	atomic_t num_remote_shutdown_ind;
	atomic_t num_tx_flow_off_ind;
	atomic_t num_tx_flow_on_ind;
	atomic_t num_rx_flow_off;
	atomic_t num_rx_flow_on;
};
65
static struct debug_fs_counter cnt;
66 67 68 69 70 71 72 73
#define	dbfs_atomic_inc(v) atomic_inc(v)
#define	dbfs_atomic_dec(v) atomic_dec(v)
#else
#define	dbfs_atomic_inc(v)
#define	dbfs_atomic_dec(v)
#endif

struct caifsock {
74
	struct sock sk; /* must be first member */
75
	struct cflayer layer;
76
	char name[CAIF_LAYER_NAME_SZ]; /* Used for debugging */
77 78
	u32 flow_state;
	struct caif_connect_request conn_req;
79
	struct mutex readlock;
80
	struct dentry *debugfs_socket_dir;
81
	int headroom, tailroom, maxframe;
82 83
};

84 85 86 87 88 89 90 91 92 93 94
static int rx_flow_is_on(struct caifsock *cf_sk)
{
	return test_bit(RX_FLOW_ON_BIT,
			(void *) &cf_sk->flow_state);
}

static int tx_flow_is_on(struct caifsock *cf_sk)
{
	return test_bit(TX_FLOW_ON_BIT,
			(void *) &cf_sk->flow_state);
}
95

96
static void set_rx_flow_off(struct caifsock *cf_sk)
97
{
98 99 100
	 clear_bit(RX_FLOW_ON_BIT,
		 (void *) &cf_sk->flow_state);
}
101

102 103 104 105 106
static void set_rx_flow_on(struct caifsock *cf_sk)
{
	 set_bit(RX_FLOW_ON_BIT,
			(void *) &cf_sk->flow_state);
}
107

108 109 110 111 112
static void set_tx_flow_off(struct caifsock *cf_sk)
{
	 clear_bit(TX_FLOW_ON_BIT,
		(void *) &cf_sk->flow_state);
}
113

114 115 116 117 118
static void set_tx_flow_on(struct caifsock *cf_sk)
{
	 set_bit(TX_FLOW_ON_BIT,
		(void *) &cf_sk->flow_state);
}
119

120 121 122 123 124 125
static void caif_read_lock(struct sock *sk)
{
	struct caifsock *cf_sk;
	cf_sk = container_of(sk, struct caifsock, sk);
	mutex_lock(&cf_sk->readlock);
}
126

127 128 129 130 131 132
static void caif_read_unlock(struct sock *sk)
{
	struct caifsock *cf_sk;
	cf_sk = container_of(sk, struct caifsock, sk);
	mutex_unlock(&cf_sk->readlock);
}
133

134
static int sk_rcvbuf_lowwater(struct caifsock *cf_sk)
135 136 137 138
{
	/* A quarter of full buffer is used a low water mark */
	return cf_sk->sk.sk_rcvbuf / 4;
}
139

140
static void caif_flow_ctrl(struct sock *sk, int mode)
141 142 143
{
	struct caifsock *cf_sk;
	cf_sk = container_of(sk, struct caifsock, sk);
144
	if (cf_sk->layer.dn && cf_sk->layer.dn->modemcmd)
145 146
		cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, mode);
}
147

148 149 150 151
/*
 * Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are
 * not dropped, but CAIF is sending flow off instead.
 */
152
static int caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
153 154 155 156 157 158
{
	int err;
	int skb_len;
	unsigned long flags;
	struct sk_buff_head *list = &sk->sk_receive_queue;
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
159

160 161
	if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
		(unsigned)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
Joe Perches's avatar
Joe Perches committed
162 163
		trace_printk("CAIF: %s(): "
			"sending flow OFF (queue len = %d %d)\n",
164 165 166 167
			__func__,
			atomic_read(&cf_sk->sk.sk_rmem_alloc),
			sk_rcvbuf_lowwater(cf_sk));
		set_rx_flow_off(cf_sk);
168 169
		dbfs_atomic_inc(&cnt.num_rx_flow_off);
		caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
170
	}
171

172 173 174 175 176
	err = sk_filter(sk, skb);
	if (err)
		return err;
	if (!sk_rmem_schedule(sk, skb->truesize) && rx_flow_is_on(cf_sk)) {
		set_rx_flow_off(cf_sk);
Joe Perches's avatar
Joe Perches committed
177 178
		trace_printk("CAIF: %s(): "
			"sending flow OFF due to rmem_schedule\n",
179
			__func__);
180 181
		dbfs_atomic_inc(&cnt.num_rx_flow_off);
		caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
	}
	skb->dev = NULL;
	skb_set_owner_r(skb, sk);
	/* Cache the SKB length before we tack it onto the receive
	 * queue. Once it is added it no longer belongs to us and
	 * may be freed by other threads of control pulling packets
	 * from the queue.
	 */
	skb_len = skb->len;
	spin_lock_irqsave(&list->lock, flags);
	if (!sock_flag(sk, SOCK_DEAD))
		__skb_queue_tail(list, skb);
	spin_unlock_irqrestore(&list->lock, flags);

	if (!sock_flag(sk, SOCK_DEAD))
		sk->sk_data_ready(sk, skb_len);
	else
		kfree_skb(skb);
200 201 202
	return 0;
}

203 204
/* Packet Receive Callback function called from CAIF Stack */
static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
205 206
{
	struct caifsock *cf_sk;
207
	struct sk_buff *skb;
208 209

	cf_sk = container_of(layr, struct caifsock, layer);
210 211 212 213 214 215 216 217 218
	skb = cfpkt_tonative(pkt);

	if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
		cfpkt_destroy(pkt);
		return 0;
	}
	caif_queue_rcv_skb(&cf_sk->sk, skb);
	return 0;
}
219

220 221 222 223 224 225
/* Packet Control Callback function called from CAIF */
static void caif_ctrl_cb(struct cflayer *layr,
				enum caif_ctrlcmd flow,
				int phyid)
{
	struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
226 227
	switch (flow) {
	case CAIF_CTRLCMD_FLOW_ON_IND:
228
		/* OK from modem to start sending again */
229
		dbfs_atomic_inc(&cnt.num_tx_flow_on_ind);
230 231
		set_tx_flow_on(cf_sk);
		cf_sk->sk.sk_state_change(&cf_sk->sk);
232 233 234
		break;

	case CAIF_CTRLCMD_FLOW_OFF_IND:
235
		/* Modem asks us to shut up */
236
		dbfs_atomic_inc(&cnt.num_tx_flow_off_ind);
237 238
		set_tx_flow_off(cf_sk);
		cf_sk->sk.sk_state_change(&cf_sk->sk);
239 240 241
		break;

	case CAIF_CTRLCMD_INIT_RSP:
242 243 244 245 246
		/* We're now connected */
		dbfs_atomic_inc(&cnt.num_connect_resp);
		cf_sk->sk.sk_state = CAIF_CONNECTED;
		set_tx_flow_on(cf_sk);
		cf_sk->sk.sk_state_change(&cf_sk->sk);
247 248 249
		break;

	case CAIF_CTRLCMD_DEINIT_RSP:
250 251 252 253
		/* We're now disconnected */
		cf_sk->sk.sk_state = CAIF_DISCONNECTED;
		cf_sk->sk.sk_state_change(&cf_sk->sk);
		cfcnfg_release_adap_layer(&cf_sk->layer);
254 255 256
		break;

	case CAIF_CTRLCMD_INIT_FAIL_RSP:
257 258 259 260 261 262 263 264 265 266 267
		/* Connect request failed */
		dbfs_atomic_inc(&cnt.num_connect_fail_resp);
		cf_sk->sk.sk_err = ECONNREFUSED;
		cf_sk->sk.sk_state = CAIF_DISCONNECTED;
		cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
		/*
		 * Socket "standards" seems to require POLLOUT to
		 * be set at connect failure.
		 */
		set_tx_flow_on(cf_sk);
		cf_sk->sk.sk_state_change(&cf_sk->sk);
268 269 270
		break;

	case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
271
		/* Modem has closed this connection, or device is down. */
272
		dbfs_atomic_inc(&cnt.num_remote_shutdown_ind);
273 274 275 276
		cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
		cf_sk->sk.sk_err = ECONNRESET;
		set_rx_flow_on(cf_sk);
		cf_sk->sk.sk_error_report(&cf_sk->sk);
277 278 279
		break;

	default:
Joe Perches's avatar
Joe Perches committed
280
		pr_debug("Unexpected flow command %d\n", flow);
281 282 283
	}
}

284
static void caif_check_flow_release(struct sock *sk)
285
{
286
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
287

288 289
	if (rx_flow_is_on(cf_sk))
		return;
290

291 292 293
	if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
			dbfs_atomic_inc(&cnt.num_rx_flow_on);
			set_rx_flow_on(cf_sk);
294
			caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_ON_REQ);
295 296
	}
}
297

298
/*
299 300
 * Copied from unix_dgram_recvmsg, but removed credit checks,
 * changed locking, address handling and added MSG_TRUNC.
301 302
 */
static int caif_seqpkt_recvmsg(struct kiocb *iocb, struct socket *sock,
303
				struct msghdr *m, size_t len, int flags)
304 305 306 307

{
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
308 309
	int ret;
	int copylen;
310

311 312 313
	ret = -EOPNOTSUPP;
	if (m->msg_flags&MSG_OOB)
		goto read_error;
314

315 316
	skb = skb_recv_datagram(sk, flags, 0 , &ret);
	if (!skb)
317
		goto read_error;
318 319 320 321
	copylen = skb->len;
	if (len < copylen) {
		m->msg_flags |= MSG_TRUNC;
		copylen = len;
322 323
	}

324
	ret = skb_copy_datagram_iovec(skb, 0, m->msg_iov, copylen);
325
	if (ret)
326
		goto out_free;
327

328 329
	ret = (flags & MSG_TRUNC) ? skb->len : copylen;
out_free:
330 331
	skb_free_datagram(sk, skb);
	caif_check_flow_release(sk);
332
	return ret;
333

334 335 336
read_error:
	return ret;
}
337 338


339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
/* Copied from unix_stream_wait_data, identical except for lock call. */
static long caif_stream_data_wait(struct sock *sk, long timeo)
{
	DEFINE_WAIT(wait);
	lock_sock(sk);

	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

		if (!skb_queue_empty(&sk->sk_receive_queue) ||
			sk->sk_err ||
			sk->sk_state != CAIF_CONNECTED ||
			sock_flag(sk, SOCK_DEAD) ||
			(sk->sk_shutdown & RCV_SHUTDOWN) ||
			signal_pending(current) ||
			!timeo)
			break;
356

357 358 359 360 361
		set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
362 363
	}

364 365 366 367
	finish_wait(sk_sleep(sk), &wait);
	release_sock(sk);
	return timeo;
}
368 369


370 371 372 373 374 375 376 377 378 379 380 381 382
/*
 * Copied from unix_stream_recvmsg, but removed credit checks,
 * changed locking calls, changed address handling.
 */
static int caif_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
				struct msghdr *msg, size_t size,
				int flags)
{
	struct sock *sk = sock->sk;
	int copied = 0;
	int target;
	int err = 0;
	long timeo;
383

384 385 386
	err = -EOPNOTSUPP;
	if (flags&MSG_OOB)
		goto out;
387

388
	msg->msg_namelen = 0;
389

390 391 392 393 394 395 396
	/*
	 * Lock the socket to prevent queue disordering
	 * while sleeps in memcpy_tomsg
	 */
	err = -EAGAIN;
	if (sk->sk_state == CAIF_CONNECTING)
		goto out;
397

398 399 400
	caif_read_lock(sk);
	target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
	timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
401

402 403 404
	do {
		int chunk;
		struct sk_buff *skb;
405

406 407 408
		lock_sock(sk);
		skb = skb_dequeue(&sk->sk_receive_queue);
		caif_check_flow_release(sk);
409

410 411 412 413 414 415 416 417 418 419 420 421
		if (skb == NULL) {
			if (copied >= target)
				goto unlock;
			/*
			 *	POSIX 1003.1g mandates this order.
			 */
			err = sock_error(sk);
			if (err)
				goto unlock;
			err = -ECONNRESET;
			if (sk->sk_shutdown & RCV_SHUTDOWN)
				goto unlock;
422

423 424 425 426 427
			err = -EPIPE;
			if (sk->sk_state != CAIF_CONNECTED)
				goto unlock;
			if (sock_flag(sk, SOCK_DEAD))
				goto unlock;
428

429
			release_sock(sk);
430

431 432 433
			err = -EAGAIN;
			if (!timeo)
				break;
434

435
			caif_read_unlock(sk);
436

437
			timeo = caif_stream_data_wait(sk, timeo);
438

439 440 441 442 443 444 445 446 447
			if (signal_pending(current)) {
				err = sock_intr_errno(timeo);
				goto out;
			}
			caif_read_lock(sk);
			continue;
unlock:
			release_sock(sk);
			break;
448
		}
449 450 451 452 453 454 455 456 457 458
		release_sock(sk);
		chunk = min_t(unsigned int, skb->len, size);
		if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
			skb_queue_head(&sk->sk_receive_queue, skb);
			if (copied == 0)
				copied = -EFAULT;
			break;
		}
		copied += chunk;
		size -= chunk;
459

460 461 462
		/* Mark read part of skb as used */
		if (!(flags & MSG_PEEK)) {
			skb_pull(skb, chunk);
463

464 465 466 467 468 469
			/* put the skb back if we didn't use it up. */
			if (skb->len) {
				skb_queue_head(&sk->sk_receive_queue, skb);
				break;
			}
			kfree_skb(skb);
470 471

		} else {
472 473 474 475 476 477
			/*
			 * It is questionable, see note in unix_dgram_recvmsg.
			 */
			/* put message back and return */
			skb_queue_head(&sk->sk_receive_queue, skb);
			break;
478
		}
479 480
	} while (size);
	caif_read_unlock(sk);
481

482 483 484
out:
	return copied ? : err;
}
485

486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
/*
 * Copied from sock.c:sock_wait_for_wmem, but change to wait for
 * CAIF flow-on and sock_writable.
 */
static long caif_wait_for_flow_on(struct caifsock *cf_sk,
				int wait_writeable, long timeo, int *err)
{
	struct sock *sk = &cf_sk->sk;
	DEFINE_WAIT(wait);
	for (;;) {
		*err = 0;
		if (tx_flow_is_on(cf_sk) &&
			(!wait_writeable || sock_writeable(&cf_sk->sk)))
			break;
		*err = -ETIMEDOUT;
		if (!timeo)
			break;
		*err = -ERESTARTSYS;
		if (signal_pending(current))
			break;
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		*err = -ECONNRESET;
		if (sk->sk_shutdown & SHUTDOWN_MASK)
			break;
		*err = -sk->sk_err;
		if (sk->sk_err)
			break;
		*err = -EPIPE;
		if (cf_sk->sk.sk_state != CAIF_CONNECTED)
			break;
		timeo = schedule_timeout(timeo);
517
	}
518 519 520
	finish_wait(sk_sleep(sk), &wait);
	return timeo;
}
521

522 523 524 525 526 527 528 529 530
/*
 * Transmit a SKB. The device may temporarily request re-transmission
 * by returning EAGAIN.
 */
static int transmit_skb(struct sk_buff *skb, struct caifsock *cf_sk,
			int noblock, long timeo)
{
	struct cfpkt *pkt;
	int ret, loopcnt = 0;
531

532 533 534
	pkt = cfpkt_fromnative(CAIF_DIR_OUT, skb);
	memset(cfpkt_info(pkt), 0, sizeof(struct caif_payload_info));
	do {
535

536
		ret = -ETIMEDOUT;
537

538 539
		/* Slight paranoia, probably not needed. */
		if (unlikely(loopcnt++ > 1000)) {
Joe Perches's avatar
Joe Perches committed
540
			pr_warn("transmit retries failed, error = %d\n", ret);
541
			break;
542 543
		}

544 545 546 547 548 549 550 551 552 553 554
		if (cf_sk->layer.dn != NULL)
			ret = cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt);
		if (likely(ret >= 0))
			break;
		/* if transmit return -EAGAIN, then retry */
		if (noblock && ret == -EAGAIN)
			break;
		timeo = caif_wait_for_flow_on(cf_sk, 0, timeo, &ret);
		if (signal_pending(current)) {
			ret = sock_intr_errno(timeo);
			break;
555
		}
556 557 558 559 560 561 562 563
		if (ret)
			break;
		if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
			sock_flag(&cf_sk->sk, SOCK_DEAD) ||
			(cf_sk->sk.sk_shutdown & RCV_SHUTDOWN)) {
			ret = -EPIPE;
			cf_sk->sk.sk_err = EPIPE;
			break;
564
		}
565 566 567
	} while (ret == -EAGAIN);
	return ret;
}
568

569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
/* Copied from af_unix:unix_dgram_sendmsg, and adapted to CAIF */
static int caif_seqpkt_sendmsg(struct kiocb *kiocb, struct socket *sock,
			struct msghdr *msg, size_t len)
{
	struct sock *sk = sock->sk;
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
	int buffer_size;
	int ret = 0;
	struct sk_buff *skb = NULL;
	int noblock;
	long timeo;
	caif_assert(cf_sk);
	ret = sock_error(sk);
	if (ret)
		goto err;

	ret = -EOPNOTSUPP;
	if (msg->msg_flags&MSG_OOB)
		goto err;

	ret = -EOPNOTSUPP;
	if (msg->msg_namelen)
		goto err;

	ret = -EINVAL;
	if (unlikely(msg->msg_iov->iov_base == NULL))
		goto err;
	noblock = msg->msg_flags & MSG_DONTWAIT;

	timeo = sock_sndtimeo(sk, noblock);
	timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
				1, timeo, &ret);

602 603
	if (ret)
		goto err;
604 605 606 607 608 609
	ret = -EPIPE;
	if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
		sock_flag(sk, SOCK_DEAD) ||
		(sk->sk_shutdown & RCV_SHUTDOWN))
		goto err;

610 611 612 613 614 615 616
	/* Error if trying to write more than maximum frame size. */
	ret = -EMSGSIZE;
	if (len > cf_sk->maxframe && cf_sk->sk.sk_protocol != CAIFPROTO_RFM)
		goto err;

	buffer_size = len + cf_sk->headroom + cf_sk->tailroom;

617 618
	ret = -ENOMEM;
	skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
619 620

	if (!skb || skb_tailroom(skb) < buffer_size)
621
		goto err;
622 623

	skb_reserve(skb, cf_sk->headroom);
624 625 626 627 628 629 630 631 632 633 634 635 636

	ret = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);

	if (ret)
		goto err;
	ret = transmit_skb(skb, cf_sk, noblock, timeo);
	if (ret < 0)
		goto err;
	return len;
err:
	kfree_skb(skb);
	return ret;
}
637

638 639 640 641 642 643 644 645 646 647 648 649 650 651
/*
 * Copied from unix_stream_sendmsg and adapted to CAIF:
 * Changed removed permission handling and added waiting for flow on
 * and other minor adaptations.
 */
static int caif_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
				struct msghdr *msg, size_t len)
{
	struct sock *sk = sock->sk;
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
	int err, size;
	struct sk_buff *skb;
	int sent = 0;
	long timeo;
652

653 654 655
	err = -EOPNOTSUPP;
	if (unlikely(msg->msg_flags&MSG_OOB))
		goto out_err;
656

657 658
	if (unlikely(msg->msg_namelen))
		goto out_err;
659

660 661
	timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
	timeo = caif_wait_for_flow_on(cf_sk, 1, timeo, &err);
662

663 664
	if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
		goto pipe_err;
665

666
	while (sent < len) {
667

668
		size = len-sent;
669

670 671
		if (size > cf_sk->maxframe)
			size = cf_sk->maxframe;
672

673 674 675
		/* If size is more than half of sndbuf, chop up message */
		if (size > ((sk->sk_sndbuf >> 1) - 64))
			size = (sk->sk_sndbuf >> 1) - 64;
676

677 678
		if (size > SKB_MAX_ALLOC)
			size = SKB_MAX_ALLOC;
679

680
		skb = sock_alloc_send_skb(sk,
681 682
					size + cf_sk->headroom +
					cf_sk->tailroom,
683 684 685 686
					msg->msg_flags&MSG_DONTWAIT,
					&err);
		if (skb == NULL)
			goto out_err;
687

688
		skb_reserve(skb, cf_sk->headroom);
689 690 691 692 693 694 695 696
		/*
		 *	If you pass two values to the sock_alloc_send_skb
		 *	it tries to grab the large buffer with GFP_NOFS
		 *	(which can fail easily), and if it fails grab the
		 *	fallback size buffer which is under a page and will
		 *	succeed. [Alan]
		 */
		size = min_t(int, size, skb_tailroom(skb));
697

698 699 700 701 702 703 704 705 706 707 708 709
		err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
		if (err) {
			kfree_skb(skb);
			goto out_err;
		}
		err = transmit_skb(skb, cf_sk,
				msg->msg_flags&MSG_DONTWAIT, timeo);
		if (err < 0) {
			kfree_skb(skb);
			goto pipe_err;
		}
		sent += size;
710 711
	}

712
	return sent;
713

714 715 716 717 718 719
pipe_err:
	if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
		send_sig(SIGPIPE, current, 0);
	err = -EPIPE;
out_err:
	return sent ? : err;
720 721 722 723 724 725 726 727 728 729
}

static int setsockopt(struct socket *sock,
			int lvl, int opt, char __user *ov, unsigned int ol)
{
	struct sock *sk = sock->sk;
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
	int prio, linksel;
	struct ifreq ifreq;

730
	if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
731
		return -ENOPROTOOPT;
732

733 734
	switch (opt) {
	case CAIFSO_LINK_SELECT:
735
		if (ol < sizeof(int))
736 737 738 739 740 741 742 743 744 745 746 747 748
			return -EINVAL;
		if (lvl != SOL_CAIF)
			goto bad_sol;
		if (copy_from_user(&linksel, ov, sizeof(int)))
			return -EINVAL;
		lock_sock(&(cf_sk->sk));
		cf_sk->conn_req.link_selector = linksel;
		release_sock(&cf_sk->sk);
		return 0;

	case SO_PRIORITY:
		if (lvl != SOL_SOCKET)
			goto bad_sol;
749
		if (ol < sizeof(int))
750 751 752 753 754 755 756 757 758 759 760
			return -EINVAL;
		if (copy_from_user(&prio, ov, sizeof(int)))
			return -EINVAL;
		lock_sock(&(cf_sk->sk));
		cf_sk->conn_req.priority = prio;
		release_sock(&cf_sk->sk);
		return 0;

	case SO_BINDTODEVICE:
		if (lvl != SOL_SOCKET)
			goto bad_sol;
761
		if (ol < sizeof(struct ifreq))
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
			return -EINVAL;
		if (copy_from_user(&ifreq, ov, sizeof(ifreq)))
			return -EFAULT;
		lock_sock(&(cf_sk->sk));
		strncpy(cf_sk->conn_req.link_name, ifreq.ifr_name,
			sizeof(cf_sk->conn_req.link_name));
		cf_sk->conn_req.link_name
			[sizeof(cf_sk->conn_req.link_name)-1] = 0;
		release_sock(&cf_sk->sk);
		return 0;

	case CAIFSO_REQ_PARAM:
		if (lvl != SOL_CAIF)
			goto bad_sol;
		if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
			return -ENOPROTOOPT;
		lock_sock(&(cf_sk->sk));
		cf_sk->conn_req.param.size = ol;
780 781
		if (ol > sizeof(cf_sk->conn_req.param.data) ||
			copy_from_user(&cf_sk->conn_req.param.data, ov, ol)) {
782 783 784 785 786 787 788
			release_sock(&cf_sk->sk);
			return -EINVAL;
		}
		release_sock(&cf_sk->sk);
		return 0;

	default:
789
		return -ENOPROTOOPT;
790 791 792 793 794 795 796 797
	}

	return 0;
bad_sol:
	return -ENOPROTOOPT;

}

798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
/*
 * caif_connect() - Connect a CAIF Socket
 * Copied and modified af_irda.c:irda_connect().
 *
 * Note : by consulting "errno", the user space caller may learn the cause
 * of the failure. Most of them are visible in the function, others may come
 * from subroutines called and are listed here :
 *  o -EAFNOSUPPORT: bad socket family or type.
 *  o -ESOCKTNOSUPPORT: bad socket type or protocol
 *  o -EINVAL: bad socket address, or CAIF link type
 *  o -ECONNREFUSED: remote end refused the connection.
 *  o -EINPROGRESS: connect request sent but timed out (or non-blocking)
 *  o -EISCONN: already connected.
 *  o -ETIMEDOUT: Connection timed out (send timeout)
 *  o -ENODEV: No link layer to send request
 *  o -ECONNRESET: Received Shutdown indication or lost link layer
 *  o -ENOMEM: Out of memory
 *
 *  State Strategy:
 *  o sk_state: holds the CAIF_* protocol state, it's updated by
 *	caif_ctrl_cb.
 *  o sock->state: holds the SS_* socket state and is updated by connect and
 *	disconnect.
 */
static int caif_connect(struct socket *sock, struct sockaddr *uaddr,
			int addr_len, int flags)
824 825
{
	struct sock *sk = sock->sk;
826 827 828
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
	long timeo;
	int err;
829 830 831
	int ifindex, headroom, tailroom;
	struct net_device *dev;

832
	lock_sock(sk);
833

834 835
	err = -EAFNOSUPPORT;
	if (uaddr->sa_family != AF_CAIF)
836 837
		goto out;

838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
	switch (sock->state) {
	case SS_UNCONNECTED:
		/* Normal case, a fresh connect */
		caif_assert(sk->sk_state == CAIF_DISCONNECTED);
		break;
	case SS_CONNECTING:
		switch (sk->sk_state) {
		case CAIF_CONNECTED:
			sock->state = SS_CONNECTED;
			err = -EISCONN;
			goto out;
		case CAIF_DISCONNECTED:
			/* Reconnect allowed */
			break;
		case CAIF_CONNECTING:
			err = -EALREADY;
			if (flags & O_NONBLOCK)
				goto out;
			goto wait_connect;
		}
		break;
	case SS_CONNECTED:
		caif_assert(sk->sk_state == CAIF_CONNECTED ||
				sk->sk_state == CAIF_DISCONNECTED);
		if (sk->sk_shutdown & SHUTDOWN_MASK) {
			/* Allow re-connect after SHUTDOWN_IND */
			caif_disconnect_client(&cf_sk->layer);
			break;
		}
		/* No reconnect on a seqpacket socket */
		err = -EISCONN;
		goto out;
	case SS_DISCONNECTING:
	case SS_FREE:
		caif_assert(1); /*Should never happen */
		break;
874
	}
875 876 877
	sk->sk_state = CAIF_DISCONNECTED;
	sock->state = SS_UNCONNECTED;
	sk_stream_kill_queues(&cf_sk->sk);
878

879
	err = -EINVAL;
880
	if (addr_len != sizeof(struct sockaddr_caif))
881
		goto out;
882

883
	memcpy(&cf_sk->conn_req.sockaddr, uaddr,
884 885
		sizeof(struct sockaddr_caif));

886 887 888 889 890 891 892
	/* Move to connecting socket, start sending Connect Requests */
	sock->state = SS_CONNECTING;
	sk->sk_state = CAIF_CONNECTING;

	dbfs_atomic_inc(&cnt.num_connect_req);
	cf_sk->layer.receive = caif_sktrecv_cb;
	err = caif_connect_client(&cf_sk->conn_req,
893
				&cf_sk->layer, &ifindex, &headroom, &tailroom);
894 895 896 897
	if (err < 0) {
		cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
		cf_sk->sk.sk_state = CAIF_DISCONNECTED;
		goto out;
898
	}
899 900 901 902 903 904
	dev = dev_get_by_index(sock_net(sk), ifindex);
	cf_sk->headroom = LL_RESERVED_SPACE_EXTRA(dev, headroom);
	cf_sk->tailroom = tailroom;
	cf_sk->maxframe = dev->mtu - (headroom + tailroom);
	dev_put(dev);
	if (cf_sk->maxframe < 1) {
Joe Perches's avatar
Joe Perches committed
905
		pr_warn("CAIF Interface MTU too small (%d)\n", dev->mtu);
906 907 908
		err = -ENODEV;
		goto out;
	}
909

910 911
	err = -EINPROGRESS;
wait_connect:
912

913 914
	if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
		goto out;
915

916 917 918
	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);

	release_sock(sk);
919 920
	err = -ERESTARTSYS;
	timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
921 922 923
			sk->sk_state != CAIF_CONNECTING,
			timeo);
	lock_sock(sk);
924
	if (timeo < 0)
925
		goto out; /* -ERESTARTSYS */
926

927 928 929
	err = -ETIMEDOUT;
	if (timeo == 0 && sk->sk_state != CAIF_CONNECTED)
		goto out;
930 931 932 933 934 935 936 937 938
	if (sk->sk_state != CAIF_CONNECTED) {
		sock->state = SS_UNCONNECTED;
		err = sock_error(sk);
		if (!err)
			err = -ECONNREFUSED;
		goto out;
	}
	sock->state = SS_CONNECTED;
	err = 0;
939
out:
940 941
	release_sock(sk);
	return err;
942 943
}

944 945 946 947 948
/*
 * caif_release() - Disconnect a CAIF Socket
 * Copied and modified af_irda.c:irda_release().
 */
static int caif_release(struct socket *sock)
949 950
{
	struct sock *sk = sock->sk;
951 952
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
	int res = 0;
953

954 955
	if (!sk)
		return 0;
956

957
	set_tx_flow_off(cf_sk);
958 959

	/*
960 961 962
	 * Ensure that packets are not queued after this point in time.
	 * caif_queue_rcv_skb checks SOCK_DEAD holding the queue lock,
	 * this ensures no packets when sock is dead.
963
	 */
964 965 966 967
	spin_lock(&sk->sk_receive_queue.lock);
	sock_set_flag(sk, SOCK_DEAD);
	spin_unlock(&sk->sk_receive_queue.lock);
	sock->sk = NULL;
968

969
	dbfs_atomic_inc(&cnt.num_disconnect);
970 971 972 973 974

	if (cf_sk->debugfs_socket_dir != NULL)
		debugfs_remove_recursive(cf_sk->debugfs_socket_dir);

	lock_sock(&(cf_sk->sk));
975 976
	sk->sk_state = CAIF_DISCONNECTED;
	sk->sk_shutdown = SHUTDOWN_MASK;
977

978 979 980
	if (cf_sk->sk.sk_socket->state == SS_CONNECTED ||
		cf_sk->sk.sk_socket->state == SS_CONNECTING)
		res = caif_disconnect_client(&cf_sk->layer);
981

982 983
	cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
	wake_up_interruptible_poll(sk_sleep(sk), POLLERR|POLLHUP);
984

985 986 987 988 989 990 991
	sock_orphan(sk);
	cf_sk->layer.dn = NULL;
	sk_stream_kill_queues(&cf_sk->sk);
	release_sock(sk);
	sock_put(sk);
	return res;
}
992

993 994 995 996 997 998 999
/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */
static unsigned int caif_poll(struct file *file,
				struct socket *sock, poll_table *wait)
{
	struct sock *sk = sock->sk;
	unsigned int mask;
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1000

1001 1002
	sock_poll_wait(file, sk_sleep(sk), wait);
	mask = 0;
1003

1004 1005 1006 1007 1008 1009 1010
	/* exceptional events? */
	if (sk->sk_err)
		mask |= POLLERR;
	if (sk->sk_shutdown == SHUTDOWN_MASK)
		mask |= POLLHUP;
	if (sk->sk_shutdown & RCV_SHUTDOWN)
		mask |= POLLRDHUP;
1011

1012 1013 1014 1015
	/* readable? */
	if (!skb_queue_empty(&sk->sk_receive_queue) ||
		(sk->sk_shutdown & RCV_SHUTDOWN))
		mask |= POLLIN | POLLRDNORM;
1016 1017

	/*
1018 1019
	 * we set writable also when the other side has shut down the
	 * connection. This prevents stuck sockets.
1020
	 */
1021 1022 1023 1024
	if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;

	return mask;
1025 1026
}

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
static const struct proto_ops caif_seqpacket_ops = {
	.family = PF_CAIF,
	.owner = THIS_MODULE,
	.release = caif_release,
	.bind = sock_no_bind,
	.connect = caif_connect,
	.socketpair = sock_no_socketpair,
	.accept = sock_no_accept,
	.getname = sock_no_getname,
	.poll = caif_poll,
	.ioctl = sock_no_ioctl,
	.listen = sock_no_listen,
	.shutdown = sock_no_shutdown,
	.setsockopt = setsockopt,
	.getsockopt = sock_no_getsockopt,
	.sendmsg = caif_seqpkt_sendmsg,
	.recvmsg = caif_seqpkt_recvmsg,
	.mmap = sock_no_mmap,
	.sendpage = sock_no_sendpage,
};

static const struct proto_ops caif_stream_ops = {
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
	.family = PF_CAIF,
	.owner = THIS_MODULE,
	.release = caif_release,
	.bind = sock_no_bind,
	.connect = caif_connect,
	.socketpair = sock_no_socketpair,
	.accept = sock_no_accept,
	.getname = sock_no_getname,
	.poll = caif_poll,
	.ioctl = sock_no_ioctl,
	.listen = sock_no_listen,
1060
	.shutdown = sock_no_shutdown,
1061 1062
	.setsockopt = setsockopt,
	.getsockopt = sock_no_getsockopt,
1063 1064
	.sendmsg = caif_stream_sendmsg,
	.recvmsg = caif_stream_recvmsg,
1065
	.mmap = sock_no_mmap,
1066
	.sendpage = sock_no_sendpage,
1067 1068 1069 1070 1071
};

/* This function is called when a socket is finally destroyed. */
static void caif_sock_destructor(struct sock *sk)
{
1072
	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1073 1074 1075 1076
	caif_assert(!atomic_read(&sk->sk_wmem_alloc));
	caif_assert(sk_unhashed(sk));
	caif_assert(!sk->sk_socket);
	if (!sock_flag(sk, SOCK_DEAD)) {
1077
		pr_info("Attempt to release alive CAIF socket: %p\n", sk);
1078 1079
		return;
	}
1080 1081
	sk_stream_kill_queues(&cf_sk->sk);
	dbfs_atomic_dec(&cnt.caif_nr_socks);
1082 1083 1084
}

static int caif_create(struct net *net, struct socket *sock, int protocol,
1085
			int kern)
1086 1087 1088 1089 1090 1091 1092 1093
{
	struct sock *sk = NULL;
	struct caifsock *cf_sk = NULL;
	static struct proto prot = {.name = "PF_CAIF",
		.owner = THIS_MODULE,
		.obj_size = sizeof(struct caifsock),
	};

1094 1095
	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN))
		return -EPERM;
1096 1097
	/*
	 * The sock->type specifies the socket type to use.
1098 1099 1100
	 * The CAIF socket is a packet stream in the sense
	 * that it is packet based. CAIF trusts the reliability
	 * of the link, no resending is implemented.
1101
	 */
1102 1103 1104 1105 1106
	if (sock->type == SOCK_SEQPACKET)
		sock->ops = &caif_seqpacket_ops;
	else if (sock->type == SOCK_STREAM)
		sock->ops = &caif_stream_ops;
	else
1107 1108 1109 1110 1111
		return -ESOCKTNOSUPPORT;

	if (protocol < 0 || protocol >= CAIFPROTO_MAX)
		return -EPROTONOSUPPORT;
	/*
1112 1113
	 * Set the socket state to unconnected.	 The socket state
	 * is really not used at all in the net/core or socket.c but the
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
	 * initialization makes sure that sock->state is not uninitialized.
	 */
	sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot);
	if (!sk)
		return -ENOMEM;

	cf_sk = container_of(sk, struct caifsock, sk);

	/* Store the protocol */
	sk->sk_protocol = (unsigned char) protocol;

1125 1126 1127
	/* Sendbuf dictates the amount of outbound packets not yet sent */
	sk->sk_sndbuf = CAIF_DEF_SNDBUF;
	sk->sk_rcvbuf = CAIF_DEF_RCVBUF;
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138

	/*
	 * Lock in order to try to stop someone from opening the socket
	 * too early.
	 */
	lock_sock(&(cf_sk->sk));

	/* Initialize the nozero default sock structure data. */
	sock_init_data(sock, sk);
	sk->sk_destruct = caif_sock_destructor;

1139 1140 1141 1142
	mutex_init(&cf_sk->readlock); /* single task reading lock */
	cf_sk->layer.ctrlcmd = caif_ctrl_cb;
	cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
	cf_sk->sk.sk_state = CAIF_DISCONNECTED;
1143

1144 1145
	set_tx_flow_off(cf_sk);
	set_rx_flow_on(cf_sk);
1146 1147 1148

	/* Set default options on configuration */
	cf_sk->conn_req.priority = CAIF_PRIO_NORMAL;
1149
	cf_sk->conn_req.link_selector = CAIF_LINK_LOW_LATENCY;
1150 1151
	cf_sk->conn_req.protocol = protocol;
	/* Increase the number of sockets created. */
1152 1153
	dbfs_atomic_inc(&cnt.caif_nr_socks);
#ifdef CONFIG_DEBUG_FS
1154
	if (!IS_ERR(debugfsdir)) {
1155 1156 1157 1158
		/* Fill in some information concerning the misc socket. */
		snprintf(cf_sk->name, sizeof(cf_sk->name), "cfsk%d",
				atomic_read(&cnt.caif_nr_socks));

1159 1160
		cf_sk->debugfs_socket_dir =
			debugfs_create_dir(cf_sk->name, debugfsdir);
1161 1162 1163
		debugfs_create_u32("sk_state", S_IRUSR | S_IWUSR,
				cf_sk->debugfs_socket_dir,
				(u32 *) &cf_sk->sk.sk_state);
1164 1165
		debugfs_create_u32("flow_state", S_IRUSR | S_IWUSR,
				cf_sk->debugfs_socket_dir, &cf_sk->flow_state);
1166 1167 1168 1169
		debugfs_create_u32("sk_rmem_alloc", S_IRUSR | S_IWUSR,
				cf_sk->debugfs_socket_dir,
				(u32 *) &cf_sk->sk.sk_rmem_alloc);
		debugfs_create_u32("sk_wmem_alloc", S_IRUSR | S_IWUSR,
1170
				cf_sk->debugfs_socket_dir,
1171
				(u32 *) &cf_sk->sk.sk_wmem_alloc);
1172 1173 1174 1175
		debugfs_create_u32("identity", S_IRUSR | S_IWUSR,
				cf_sk->debugfs_socket_dir,
				(u32 *) &cf_sk->layer.id);
	}
1176
#endif
1177 1178 1179 1180
	release_sock(&cf_sk->sk);
	return 0;
}

1181

1182 1183 1184 1185 1186 1187
static struct net_proto_family caif_family_ops = {
	.family = PF_CAIF,
	.create = caif_create,
	.owner = THIS_MODULE,
};

1188
static int af_caif_init(void)
1189
{
1190
	int err = sock_register(&caif_family_ops);
1191 1192 1193 1194 1195 1196 1197 1198
	if (!err)
		return err;
	return 0;
}

static int __init caif_sktinit_module(void)
{
#ifdef CONFIG_DEBUG_FS
1199
	debugfsdir = debugfs_create_dir("caif_sk", NULL);
1200 1201 1202
	if (!IS_ERR(debugfsdir)) {
		debugfs_create_u32("num_sockets", S_IRUSR | S_IWUSR,
				debugfsdir,
1203 1204
				(u32 *) &cnt.caif_nr_socks);
		debugfs_create_u32("num_connect_req", S_IRUSR | S_IWUSR,
1205
				debugfsdir,
1206 1207
				(u32 *) &cnt.num_connect_req);
		debugfs_create_u32("num_connect_resp", S_IRUSR | S_IWUSR,
1208
				debugfsdir,
1209 1210
				(u32 *) &cnt.num_connect_resp);
		debugfs_create_u32("num_connect_fail_resp", S_IRUSR | S_IWUSR,
1211
				debugfsdir,
1212 1213
				(u32 *) &cnt.num_connect_fail_resp);
		debugfs_create_u32("num_disconnect", S_IRUSR | S_IWUSR,
1214
				debugfsdir,
1215
				(u32 *) &cnt.num_disconnect);
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
		debugfs_create_u32("num_remote_shutdown_ind",
				S_IRUSR | S_IWUSR, debugfsdir,
				(u32 *) &cnt.num_remote_shutdown_ind);
		debugfs_create_u32("num_tx_flow_off_ind", S_IRUSR | S_IWUSR,
				debugfsdir,
				(u32 *) &cnt.num_tx_flow_off_ind);
		debugfs_create_u32("num_tx_flow_on_ind", S_IRUSR | S_IWUSR,
				debugfsdir,
				(u32 *) &cnt.num_tx_flow_on_ind);
		debugfs_create_u32("num_rx_flow_off", S_IRUSR | S_IWUSR,
				debugfsdir,
				(u32 *) &cnt.num_rx_flow_off);
		debugfs_create_u32("num_rx_flow_on", S_IRUSR | S_IWUSR,
				debugfsdir,
				(u32 *) &cnt.num_rx_flow_on);
	}
#endif
1233
	return af_caif_init();
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
}

static void __exit caif_sktexit_module(void)
{
	sock_unregister(PF_CAIF);
	if (debugfsdir != NULL)
		debugfs_remove_recursive(debugfsdir);
}
module_init(caif_sktinit_module);
module_exit(caif_sktexit_module);