[mirror_frr.git] / bgpd / bgp_keepalives.c

/* BGP Keepalives.
 * Implements a producer thread to generate BGP keepalives for peers.
 * Copyright (C) 2017 Cumulus Networks, Inc.
 * Quentin Young
 *
 * This file is part of FRRouting.
 *
 * FRRouting is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2, or (at your option) any later
 * version.
 *
 * FRRouting is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

/* clang-format off */
#include <zebra.h>
#include <pthread.h>		// for pthread_mutex_lock, pthread_mutex_unlock

#include "frr_pthread.h"        // for frr_pthread
#include "hash.h"		// for hash, hash_clean, hash_create_size...
#include "log.h"		// for zlog_debug
#include "memory.h"		// for MTYPE_TMP, XFREE, XCALLOC, XMALLOC
#include "monotime.h"		// for monotime, monotime_since

#include "bgpd/bgpd.h"          // for peer, PEER_THREAD_KEEPALIVES_ON, peer...
#include "bgpd/bgp_debug.h"	// for bgp_debug_neighbor_events
#include "bgpd/bgp_packet.h"	// for bgp_keepalive_send
#include "bgpd/bgp_keepalives.h"
/* clang-format on */

/*
 * Peer KeepAlive Timer.
 * Associates a peer with the time of its last keepalive.
 */
struct pkat {
	/* the peer to send keepalives to */
	struct peer *peer;
	/* absolute time of last keepalive sent */
	struct timeval last;
};

/* List of peers we are sending keepalives for, and associated mutex. */
static pthread_mutex_t *peerhash_mtx;
static pthread_cond_t *peerhash_cond;
static struct hash *peerhash;

static struct pkat *pkat_new(struct peer *peer)
{
	struct pkat *pkat = XMALLOC(MTYPE_TMP, sizeof(struct pkat));
	pkat->peer = peer;
	monotime(&pkat->last);
	return pkat;
}

static void pkat_del(void *pkat)
{
	XFREE(MTYPE_TMP, pkat);
}


/*
 * Callback for hash_iterate. Determines if a peer needs a keepalive and if so,
 * generates and sends it.
 *
 * For any given peer, if the elapsed time since its last keepalive exceeds its
 * configured keepalive timer, a keepalive is sent to the peer and its
 * last-sent time is reset. Additionally, If the elapsed time does not exceed
 * the configured keepalive timer, but the time until the next keepalive is due
 * is within a hardcoded tolerance, a keepalive is sent as if the configured
 * timer was exceeded. Doing this helps alleviate nanosecond sleeps between
 * ticks by grouping together peers who are due for keepalives at roughly the
 * same time. This tolerance value is arbitrarily chosen to be 100ms.
 *
 * In addition, this function calculates the maximum amount of time that the
 * keepalive thread can sleep before another tick needs to take place. This is
 * equivalent to shortest time until a keepalive is due for any one peer.
 *
 * @return maximum time to wait until next update (0 if infinity)
 */
static void peer_process(struct hash_bucket *hb, void *arg)
{
	struct pkat *pkat = hb->data;

	struct timeval *next_update = arg;

	static struct timeval elapsed;  // elapsed time since keepalive
	static struct timeval ka = {0}; // peer->v_keepalive as a timeval
	static struct timeval diff;     // ka - elapsed

	static struct timeval tolerance = {0, 100000};

	/* calculate elapsed time since last keepalive */
	monotime_since(&pkat->last, &elapsed);

	/* calculate difference between elapsed time and configured time */
	ka.tv_sec = pkat->peer->v_keepalive;
	timersub(&ka, &elapsed, &diff);

	int send_keepalive =
		elapsed.tv_sec >= ka.tv_sec || timercmp(&diff, &tolerance, <);

	if (send_keepalive) {
		if (bgp_debug_neighbor_events(pkat->peer))
			zlog_debug("%s [FSM] Timer (keepalive timer expire)",
				   pkat->peer->host);

		bgp_keepalive_send(pkat->peer);
		monotime(&pkat->last);
		memset(&elapsed, 0x00, sizeof(struct timeval));
		diff = ka;
	}

	/* if calculated next update for this peer < current delay, use it */
	if (next_update->tv_sec < 0 || timercmp(&diff, next_update, <))
		*next_update = diff;
}

static bool peer_hash_cmp(const void *f, const void *s)
{
	const struct pkat *p1 = f;
	const struct pkat *p2 = s;

	return p1->peer == p2->peer;
}

static unsigned int peer_hash_key(void *arg)
{
	struct pkat *pkat = arg;
	return (uintptr_t)pkat->peer;
}

/* Cleanup handler / deinitializer. */
static void bgp_keepalives_finish(void *arg)
{
	if (peerhash) {
		hash_clean(peerhash, pkat_del);
		hash_free(peerhash);
	}

	peerhash = NULL;

	pthread_mutex_unlock(peerhash_mtx);
	pthread_mutex_destroy(peerhash_mtx);
	pthread_cond_destroy(peerhash_cond);

	XFREE(MTYPE_TMP, peerhash_mtx);
	XFREE(MTYPE_TMP, peerhash_cond);
}

/*
 * Entry function for peer keepalive generation pthread.
 */
void *bgp_keepalives_start(void *arg)
{
	struct frr_pthread *fpt = arg;
	fpt->master->owner = pthread_self();

	struct timeval currtime = {0, 0};
	struct timeval aftertime = {0, 0};
	struct timeval next_update = {0, 0};
	struct timespec next_update_ts = {0, 0};

	peerhash_mtx = XCALLOC(MTYPE_TMP, sizeof(pthread_mutex_t));
	peerhash_cond = XCALLOC(MTYPE_TMP, sizeof(pthread_cond_t));

	/* initialize mutex */
	pthread_mutex_init(peerhash_mtx, NULL);

	/* use monotonic clock with condition variable */
	pthread_condattr_t attrs;
	pthread_condattr_init(&attrs);
	pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC);
	pthread_cond_init(peerhash_cond, &attrs);
	pthread_condattr_destroy(&attrs);

	/*
	 * We are not using normal FRR pthread mechanics and are
	 * not using fpt_run
	 */
	frr_pthread_set_name(fpt);

	/* initialize peer hashtable */
	peerhash = hash_create_size(2048, peer_hash_key, peer_hash_cmp, NULL);
	pthread_mutex_lock(peerhash_mtx);

	/* register cleanup handler */
	pthread_cleanup_push(&bgp_keepalives_finish, NULL);

	/* notify anybody waiting on us that we are done starting up */
	frr_pthread_notify_running(fpt);

	while (atomic_load_explicit(&fpt->running, memory_order_relaxed)) {
		if (peerhash->count > 0)
			pthread_cond_timedwait(peerhash_cond, peerhash_mtx,
					       &next_update_ts);
		else
			while (peerhash->count == 0
			       && atomic_load_explicit(&fpt->running,
						       memory_order_relaxed))
				pthread_cond_wait(peerhash_cond, peerhash_mtx);

		monotime(&currtime);

		next_update.tv_sec = -1;

		hash_iterate(peerhash, peer_process, &next_update);
		if (next_update.tv_sec == -1)
			memset(&next_update, 0x00, sizeof(next_update));

		monotime_since(&currtime, &aftertime);

		timeradd(&currtime, &next_update, &next_update);
		TIMEVAL_TO_TIMESPEC(&next_update, &next_update_ts);
	}

	/* clean up */
	pthread_cleanup_pop(1);

	return NULL;
}

/* --- thread external functions ------------------------------------------- */

void bgp_keepalives_on(struct peer *peer)
{
	if (CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON))
		return;

	struct frr_pthread *fpt = bgp_pth_ka;
	assert(fpt->running);

	/* placeholder bucket data to use for fast key lookups */
	static struct pkat holder = {0};

	/*
	 * We need to ensure that bgp_keepalives_init was called first
	 */
	assert(peerhash_mtx);

	pthread_mutex_lock(peerhash_mtx);
	{
		holder.peer = peer;
		if (!hash_lookup(peerhash, &holder)) {
			struct pkat *pkat = pkat_new(peer);
			hash_get(peerhash, pkat, hash_alloc_intern);
			peer_lock(peer);
		}
		SET_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON);
	}
	pthread_mutex_unlock(peerhash_mtx);
	bgp_keepalives_wake();
}

void bgp_keepalives_off(struct peer *peer)
{
	if (!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON))
		return;

	struct frr_pthread *fpt = bgp_pth_ka;
	assert(fpt->running);

	/* placeholder bucket data to use for fast key lookups */
	static struct pkat holder = {0};

	/*
	 * We need to ensure that bgp_keepalives_init was called first
	 */
	assert(peerhash_mtx);

	pthread_mutex_lock(peerhash_mtx);
	{
		holder.peer = peer;
		struct pkat *res = hash_release(peerhash, &holder);
		if (res) {
			pkat_del(res);
			peer_unlock(peer);
		}
		UNSET_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON);
	}
	pthread_mutex_unlock(peerhash_mtx);
}

void bgp_keepalives_wake(void)
{
	pthread_mutex_lock(peerhash_mtx);
	{
		pthread_cond_signal(peerhash_cond);
	}
	pthread_mutex_unlock(peerhash_mtx);
}

int bgp_keepalives_stop(struct frr_pthread *fpt, void **result)
{
	assert(fpt->running);

	atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
	bgp_keepalives_wake();

	pthread_join(fpt->thread, result);
	return 0;
}
Commit	Line	Data
5c0c651c QY	1	/* BGP Keepalives.
	2	* Implements a producer thread to generate BGP keepalives for peers.
	3	* Copyright (C) 2017 Cumulus Networks, Inc.
	4	* Quentin Young
	5	*
	6	* This file is part of FRRouting.
	7	*
	8	* FRRouting is free software; you can redistribute it and/or modify it under
	9	* the terms of the GNU General Public License as published by the Free
	10	* Software Foundation; either version 2, or (at your option) any later
	11	* version.
	12	*
	13	* FRRouting is distributed in the hope that it will be useful, but WITHOUT ANY
	14	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	15	* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
	16	* details.
	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
03014d48	21	*/
5c0c651c	22
6ee8ea1c	23	/* clang-format off */
03014d48	24	#include <zebra.h>
6ee8ea1c	25	#include <pthread.h> // for pthread_mutex_lock, pthread_mutex_unlock
03014d48	26
6ee8ea1c QY	27	#include "frr_pthread.h" // for frr_pthread
	28	#include "hash.h" // for hash, hash_clean, hash_create_size...
	29	#include "log.h" // for zlog_debug
	30	#include "memory.h" // for MTYPE_TMP, XFREE, XCALLOC, XMALLOC
	31	#include "monotime.h" // for monotime, monotime_since
03014d48	32
6ee8ea1c QY	33	#include "bgpd/bgpd.h" // for peer, PEER_THREAD_KEEPALIVES_ON, peer...
	34	#include "bgpd/bgp_debug.h" // for bgp_debug_neighbor_events
	35	#include "bgpd/bgp_packet.h" // for bgp_keepalive_send
03014d48	36	#include "bgpd/bgp_keepalives.h"
6ee8ea1c	37	/* clang-format on */
03014d48	38
a715eab3	39	/*
03014d48 QY	40	* Peer KeepAlive Timer.
	41	* Associates a peer with the time of its last keepalive.
	42	*/
	43	struct pkat {
a715eab3	44	/* the peer to send keepalives to */
03014d48	45	struct peer *peer;
a715eab3	46	/* absolute time of last keepalive sent */
03014d48 QY	47	struct timeval last;
	48	};
	49
	50	/* List of peers we are sending keepalives for, and associated mutex. */
bd8b71e4 QY	51	static pthread_mutex_t *peerhash_mtx;
	52	static pthread_cond_t *peerhash_cond;
	53	static struct hash *peerhash;
03014d48	54
03014d48 QY	55	static struct pkat pkat_new(struct peer peer)
	56	{
	57	struct pkat *pkat = XMALLOC(MTYPE_TMP, sizeof(struct pkat));
	58	pkat->peer = peer;
	59	monotime(&pkat->last);
	60	return pkat;
	61	}
	62
	63	static void pkat_del(void *pkat)
	64	{
	65	XFREE(MTYPE_TMP, pkat);
	66	}
03014d48	67
bd8b71e4	68
03014d48	69	/*
424ab01d QY	70	* Callback for hash_iterate. Determines if a peer needs a keepalive and if so,
424ab01d QY	71	* generates and sends it.
03014d48 QY	72	*
	73	* For any given peer, if the elapsed time since its last keepalive exceeds its
	74	* configured keepalive timer, a keepalive is sent to the peer and its
	75	* last-sent time is reset. Additionally, If the elapsed time does not exceed
	76	* the configured keepalive timer, but the time until the next keepalive is due
	77	* is within a hardcoded tolerance, a keepalive is sent as if the configured
	78	* timer was exceeded. Doing this helps alleviate nanosecond sleeps between
	79	* ticks by grouping together peers who are due for keepalives at roughly the
	80	* same time. This tolerance value is arbitrarily chosen to be 100ms.
	81	*
	82	* In addition, this function calculates the maximum amount of time that the
	83	* keepalive thread can sleep before another tick needs to take place. This is
	84	* equivalent to shortest time until a keepalive is due for any one peer.
	85	*
	86	* @return maximum time to wait until next update (0 if infinity)
	87	*/
e3b78da8	88	static void peer_process(struct hash_bucket hb, void arg)
03014d48	89	{
bd8b71e4 QY	90	struct pkat *pkat = hb->data;
	91
	92	struct timeval *next_update = arg;
03014d48	93
03014d48 QY	94	static struct timeval elapsed; // elapsed time since keepalive
	95	static struct timeval ka = {0}; // peer->v_keepalive as a timeval
	96	static struct timeval diff; // ka - elapsed
	97
03014d48 QY	98	static struct timeval tolerance = {0, 100000};
03014d48 QY	99
a715eab3	100	/* calculate elapsed time since last keepalive */
bd8b71e4	101	monotime_since(&pkat->last, &elapsed);
03014d48	102
a715eab3	103	/* calculate difference between elapsed time and configured time */
bd8b71e4 QY	104	ka.tv_sec = pkat->peer->v_keepalive;
bd8b71e4 QY	105	timersub(&ka, &elapsed, &diff);
03014d48	106
bd8b71e4 QY	107	int send_keepalive =
bd8b71e4 QY	108	elapsed.tv_sec >= ka.tv_sec \|\| timercmp(&diff, &tolerance, <);
03014d48	109
bd8b71e4 QY	110	if (send_keepalive) {
	111	if (bgp_debug_neighbor_events(pkat->peer))
	112	zlog_debug("%s [FSM] Timer (keepalive timer expire)",
	113	pkat->peer->host);
03014d48	114
bd8b71e4 QY	115	bgp_keepalive_send(pkat->peer);
	116	monotime(&pkat->last);
	117	memset(&elapsed, 0x00, sizeof(struct timeval));
a715eab3	118	diff = ka;
03014d48 QY	119	}
03014d48 QY	120
a715eab3	121	/* if calculated next update for this peer < current delay, use it */
2ccf91b1	122	if (next_update->tv_sec < 0 \|\| timercmp(&diff, next_update, <))
bd8b71e4 QY	123	*next_update = diff;
	124	}
	125
74df8d6d	126	static bool peer_hash_cmp(const void f, const void s)
bd8b71e4 QY	127	{
	128	const struct pkat *p1 = f;
	129	const struct pkat *p2 = s;
74df8d6d	130
bd8b71e4 QY	131	return p1->peer == p2->peer;
	132	}
	133
	134	static unsigned int peer_hash_key(void *arg)
	135	{
	136	struct pkat *pkat = arg;
	137	return (uintptr_t)pkat->peer;
03014d48 QY	138	}
03014d48 QY	139
a715eab3	140	/* Cleanup handler / deinitializer. */
b72b6f4f	141	static void bgp_keepalives_finish(void *arg)
419dfe6a	142	{
bd8b71e4 QY	143	if (peerhash) {
	144	hash_clean(peerhash, pkat_del);
	145	hash_free(peerhash);
	146	}
419dfe6a	147
bd8b71e4	148	peerhash = NULL;
419dfe6a	149
bd8b71e4 QY	150	pthread_mutex_unlock(peerhash_mtx);
	151	pthread_mutex_destroy(peerhash_mtx);
	152	pthread_cond_destroy(peerhash_cond);
419dfe6a	153
424ab01d QY	154	XFREE(MTYPE_TMP, peerhash_mtx);
424ab01d QY	155	XFREE(MTYPE_TMP, peerhash_cond);
419dfe6a QY	156	}
419dfe6a QY	157
a715eab3	158	/*
419dfe6a	159	* Entry function for peer keepalive generation pthread.
419dfe6a	160	*/
b72b6f4f	161	void bgp_keepalives_start(void arg)
419dfe6a	162	{
a715eab3 QY	163	struct frr_pthread *fpt = arg;
	164	fpt->master->owner = pthread_self();
	165
419dfe6a	166	struct timeval currtime = {0, 0};
bd8b71e4	167	struct timeval aftertime = {0, 0};
419dfe6a QY	168	struct timeval next_update = {0, 0};
	169	struct timespec next_update_ts = {0, 0};
	170
a715eab3 QY	171	peerhash_mtx = XCALLOC(MTYPE_TMP, sizeof(pthread_mutex_t));
	172	peerhash_cond = XCALLOC(MTYPE_TMP, sizeof(pthread_cond_t));
	173
	174	/* initialize mutex */
	175	pthread_mutex_init(peerhash_mtx, NULL);
	176
	177	/* use monotonic clock with condition variable */
	178	pthread_condattr_t attrs;
	179	pthread_condattr_init(&attrs);
	180	pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC);
	181	pthread_cond_init(peerhash_cond, &attrs);
	182	pthread_condattr_destroy(&attrs);
	183
c80bedb8 DS	184	/*
	185	* We are not using normal FRR pthread mechanics and are
	186	* not using fpt_run
	187	*/
	188	frr_pthread_set_name(fpt);
a9198bc1	189
a715eab3 QY	190	/* initialize peer hashtable */
a715eab3 QY	191	peerhash = hash_create_size(2048, peer_hash_key, peer_hash_cmp, NULL);
bd8b71e4	192	pthread_mutex_lock(peerhash_mtx);
03014d48	193
a715eab3	194	/* register cleanup handler */
b72b6f4f	195	pthread_cleanup_push(&bgp_keepalives_finish, NULL);
03014d48	196
a715eab3 QY	197	/* notify anybody waiting on us that we are done starting up */
a715eab3 QY	198	frr_pthread_notify_running(fpt);
03014d48	199
a715eab3	200	while (atomic_load_explicit(&fpt->running, memory_order_relaxed)) {
bd8b71e4 QY	201	if (peerhash->count > 0)
bd8b71e4 QY	202	pthread_cond_timedwait(peerhash_cond, peerhash_mtx,
03014d48 QY	203	&next_update_ts);
03014d48 QY	204	else
bd8b71e4	205	while (peerhash->count == 0
a715eab3 QY	206	&& atomic_load_explicit(&fpt->running,
a715eab3 QY	207	memory_order_relaxed))
bd8b71e4	208	pthread_cond_wait(peerhash_cond, peerhash_mtx);
03014d48 QY	209
03014d48 QY	210	monotime(&currtime);
bd8b71e4 QY	211
	212	next_update.tv_sec = -1;
	213
	214	hash_iterate(peerhash, peer_process, &next_update);
	215	if (next_update.tv_sec == -1)
	216	memset(&next_update, 0x00, sizeof(next_update));
	217
	218	monotime_since(&currtime, &aftertime);
	219
03014d48 QY	220	timeradd(&currtime, &next_update, &next_update);
	221	TIMEVAL_TO_TIMESPEC(&next_update, &next_update_ts);
	222	}
	223
a715eab3	224	/* clean up */
03014d48 QY	225	pthread_cleanup_pop(1);
	226
	227	return NULL;
	228	}
	229
	230	/* --- thread external functions ------------------------------------------- */
	231
b72b6f4f	232	void bgp_keepalives_on(struct peer *peer)
03014d48	233	{
096476dd QY	234	if (CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON))
	235	return;
	236
1ac267a2	237	struct frr_pthread *fpt = bgp_pth_ka;
a715eab3 QY	238	assert(fpt->running);
a715eab3 QY	239
bd8b71e4 QY	240	/* placeholder bucket data to use for fast key lookups */
	241	static struct pkat holder = {0};
	242
68ede9c4 DS	243	/*
	244	* We need to ensure that bgp_keepalives_init was called first
	245	*/
	246	assert(peerhash_mtx);
934af458	247
bd8b71e4	248	pthread_mutex_lock(peerhash_mtx);
03014d48	249	{
bd8b71e4 QY	250	holder.peer = peer;
	251	if (!hash_lookup(peerhash, &holder)) {
	252	struct pkat *pkat = pkat_new(peer);
	253	hash_get(peerhash, pkat, hash_alloc_intern);
	254	peer_lock(peer);
	255	}
49507a6f	256	SET_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON);
03014d48	257	}
bd8b71e4	258	pthread_mutex_unlock(peerhash_mtx);
b72b6f4f	259	bgp_keepalives_wake();
03014d48 QY	260	}
03014d48 QY	261
b72b6f4f	262	void bgp_keepalives_off(struct peer *peer)
03014d48	263	{
096476dd QY	264	if (!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON))
	265	return;
	266
1ac267a2	267	struct frr_pthread *fpt = bgp_pth_ka;
a715eab3 QY	268	assert(fpt->running);
a715eab3 QY	269
bd8b71e4 QY	270	/* placeholder bucket data to use for fast key lookups */
bd8b71e4 QY	271	static struct pkat holder = {0};
49507a6f	272
68ede9c4 DS	273	/*
	274	* We need to ensure that bgp_keepalives_init was called first
	275	*/
	276	assert(peerhash_mtx);
934af458	277
bd8b71e4 QY	278	pthread_mutex_lock(peerhash_mtx);
	279	{
	280	holder.peer = peer;
	281	struct pkat *res = hash_release(peerhash, &holder);
	282	if (res) {
	283	pkat_del(res);
	284	peer_unlock(peer);
	285	}
49507a6f	286	UNSET_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON);
03014d48	287	}
bd8b71e4	288	pthread_mutex_unlock(peerhash_mtx);
03014d48 QY	289	}
03014d48 QY	290
4d762f26	291	void bgp_keepalives_wake(void)
03014d48	292	{
bd8b71e4	293	pthread_mutex_lock(peerhash_mtx);
03014d48	294	{
bd8b71e4	295	pthread_cond_signal(peerhash_cond);
03014d48	296	}
bd8b71e4	297	pthread_mutex_unlock(peerhash_mtx);
03014d48	298	}
0ca8b79f	299
a715eab3	300	int bgp_keepalives_stop(struct frr_pthread fpt, void *result)
0ca8b79f	301	{
a715eab3 QY	302	assert(fpt->running);
	303
	304	atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
b72b6f4f	305	bgp_keepalives_wake();
a715eab3	306
0ca8b79f QY	307	pthread_join(fpt->thread, result);
	308	return 0;
	309	}