dect
/
asterisk
Archived
13
0
Fork 0
Code Releases Activity

Merge team/russell/frame_caching 

There are some situations in Asterisk where ast_frame and/or iax_frame
structures are rapidly allocatted and freed (at least 50 times per second
for one call).

This code significantly improves the performance of ast_frame_header_new(), 
ast_frdup(), ast_frfree(), iax_frame_new(), and iax_frame_free() by keeping
a thread-local cache of these structures and using frames from the cache 
whenever possible instead of calling malloc/free every time.

This commit also converts the ast_frame and iax_frame structures to use the
linked list macros.


git-svn-id: http://svn.digium.com/svn/asterisk/trunk@41278 f38db490-d61c-443f-a65b-d21fe96a405b
This commit is contained in:
russell 2006-08-29 20:50:36 +00:00
parent 562decf81a
commit 53f8d43e29
16 changed files with 345 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
apps/app_milliwatt.c
View File

@ -66,10 +66,16 @@ static void milliwatt_release(struct ast_channel *chan, void *data)
static int milliwatt_generate(struct ast_channel *chan, void *data, int len, int samples)
{
struct ast_frame wf;
unsigned char buf[AST_FRIENDLY_OFFSET + 640];
const int maxsamples = sizeof (buf) / sizeof (buf[0]);
int i, *indexp = (int *) data;
struct ast_frame wf = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_ULAW,
.offset = AST_FRIENDLY_OFFSET,
.data = buf + AST_FRIENDLY_OFFSET,
.src = __FUNCTION__,
};
/* Instead of len, use samples, because channel.c generator_force
* generate(chan, tmp, 0, 160) ignores len. In any case, len is
@ -82,17 +88,8 @@ static int milliwatt_generate(struct ast_channel *chan, void *data, int len, int
samples = maxsamples;
}
len = samples * sizeof (buf[0]);
wf.frametype = AST_FRAME_VOICE;
wf.subclass = AST_FORMAT_ULAW;
wf.offset = AST_FRIENDLY_OFFSET;
wf.mallocd = 0;
wf.data = buf + AST_FRIENDLY_OFFSET;
wf.datalen = len;
wf.samples = samples;
wf.src = "app_milliwatt";
wf.delivery.tv_sec = 0;
wf.delivery.tv_usec = 0;
wf.prev = wf.next = NULL;
/* create a buffer containing the digital milliwatt pattern */
for(i = 0; i < len; i++)
{

2
apps/app_mixmonitor.c
View File

@ -191,7 +191,7 @@ static void *mixmonitor_thread(void *obj)
of frames if a queue flush was necessary, so process them
*/
for (; f; f = next) {
next = f->next;
next = AST_LIST_NEXT(f, frame_list);
if (write)
ast_writestream(mixmonitor->fs, f);
ast_frfree(f);

142
channels/chan_iax2.c
View File

@ -621,11 +621,11 @@ struct chan_iax2_pvt {
};
static struct ast_iax2_queue {
struct iax_frame *head;
struct iax_frame *tail;
AST_LIST_HEAD(, iax_frame) queue;
int count;
ast_mutex_t lock;
} iaxq;
} iaxq = {
.queue = AST_LIST_HEAD_INIT_VALUE
};
static AST_LIST_HEAD_STATIC(users, iax2_user);
@ -1071,11 +1071,12 @@ static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, cons
static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
{
/* Malloc() a copy of a frame */
struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen);
if (new) {
memcpy(new, fr, sizeof(struct iax_frame));
size_t mallocd_datalen = new->mallocd_datalen;
memcpy(new, fr, sizeof(*new));
iax_frame_wrap(new, &fr->af);
new->mallocd_datalen = mallocd_datalen;
new->data = NULL;
new->datalen = 0;
new->direction = DIRECTION_INGRESS;
@ -1754,7 +1755,7 @@ retry:
ast_queue_hangup(owner);
}
for (cur = iaxq.head; cur ; cur = cur->next) {
AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
/* Cancel any pending transmissions */
if (cur->callno == pvt->callno)
cur->retries = -1;
@ -1875,17 +1876,10 @@ static void __attempt_transmit(void *data)
/* Do not try again */
if (freeme) {
/* Don't attempt delivery, just remove it from the queue */
ast_mutex_lock(&iaxq.lock);
if (f->prev)
f->prev->next = f->next;
else
iaxq.head = f->next;
if (f->next)
f->next->prev = f->prev;
else
iaxq.tail = f->prev;
AST_LIST_LOCK(&iaxq.queue);
AST_LIST_REMOVE(&iaxq.queue, f, list);
iaxq.count--;
ast_mutex_unlock(&iaxq.lock);
AST_LIST_UNLOCK(&iaxq.queue);
f->retrans = -1;
/* Free the IAX frame */
iax2_frame_free(f);
@ -2082,7 +2076,7 @@ static int iax2_show_stats(int fd, int argc, char *argv[])
int cnt = 0, dead=0, final=0;
if (argc != 3)
return RESULT_SHOWUSAGE;
for (cur = iaxq.head; cur ; cur = cur->next) {
AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
if (cur->retries < 0)
dead++;
if (cur->final)
@ -2092,7 +2086,8 @@ static int iax2_show_stats(int fd, int argc, char *argv[])
ast_cli(fd, " IAX Statistics\n");
ast_cli(fd, "---------------------\n");
ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n", dead, final, cnt);
ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
return RESULT_SUCCESS;
}
@ -2369,24 +2364,13 @@ static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtr
static int iax2_transmit(struct iax_frame *fr)
{
/* Lock the queue and place this packet at the end */
fr->next = NULL;
fr->prev = NULL;
/* By setting this to 0, the network thread will send it for us, and
queue retransmission if necessary */
fr->sentyet = 0;
ast_mutex_lock(&iaxq.lock);
if (!iaxq.head) {
/* Empty queue */
iaxq.head = fr;
iaxq.tail = fr;
} else {
/* Double link */
iaxq.tail->next = fr;
fr->prev = iaxq.tail;
iaxq.tail = fr;
}
AST_LIST_LOCK(&iaxq.queue);
AST_LIST_INSERT_TAIL(&iaxq.queue, fr, list);
iaxq.count++;
ast_mutex_unlock(&iaxq.lock);
AST_LIST_UNLOCK(&iaxq.queue);
/* Wake up the network and scheduler thread */
pthread_kill(netthreadid, SIGURG);
signal_condition(&sched_lock, &sched_cond);
@ -5330,15 +5314,15 @@ static int complete_transfer(int callno, struct iax_ies *ies)
pvt->lastsent = 0;
pvt->nextpred = 0;
pvt->pingtime = DEFAULT_RETRY_TIME;
ast_mutex_lock(&iaxq.lock);
for (cur = iaxq.head; cur ; cur = cur->next) {
AST_LIST_LOCK(&iaxq.queue);
AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
/* We must cancel any packets that would have been transmitted
because now we're talking to someone new. It's okay, they
were transmitted to someone that didn't care anyway. */
if (callno == cur->callno)
cur->retries = -1;
}
ast_mutex_unlock(&iaxq.lock);
AST_LIST_UNLOCK(&iaxq.queue);
return 0;
}
@ -5835,17 +5819,16 @@ static int iax2_vnak(int callno)
static void vnak_retransmit(int callno, int last)
{
struct iax_frame *f;
ast_mutex_lock(&iaxq.lock);
f = iaxq.head;
while(f) {
AST_LIST_LOCK(&iaxq.queue);
AST_LIST_TRAVERSE(&iaxq.queue, f, list) {
/* Send a copy immediately */
if ((f->callno == callno) && iaxs[f->callno] &&
(f->oseqno >= last)) {
send_packet(f);
}
f = f->next;
}
ast_mutex_unlock(&iaxq.lock);
AST_LIST_UNLOCK(&iaxq.queue);
}
static void __iax2_poke_peer_s(void *data)
@ -6570,8 +6553,8 @@ static int socket_process(struct iax2_thread *thread)
/* Ack the packet with the given timestamp */
if (option_debug && iaxdebug)
ast_log(LOG_DEBUG, "Cancelling transmission of packet %d\n", x);
ast_mutex_lock(&iaxq.lock);
for (cur = iaxq.head; cur ; cur = cur->next) {
AST_LIST_LOCK(&iaxq.queue);
AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
/* If it's our call, and our timestamp, mark -1 retries */
if ((fr->callno == cur->callno) && (x == cur->oseqno)) {
cur->retries = -1;
@ -6583,7 +6566,7 @@ static int socket_process(struct iax2_thread *thread)
}
}
}
ast_mutex_unlock(&iaxq.lock);
AST_LIST_UNLOCK(&iaxq.queue);
}
/* Note how much we've received acknowledgement for */
if (iaxs[fr->callno])
@ -6723,13 +6706,13 @@ retryowner:
case IAX_COMMAND_TXACC:
if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
/* Ack the packet with the given timestamp */
ast_mutex_lock(&iaxq.lock);
for (cur = iaxq.head; cur ; cur = cur->next) {
AST_LIST_LOCK(&iaxq.queue);
AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
/* Cancel any outstanding txcnt's */
if ((fr->callno == cur->callno) && (cur->transfer))
cur->retries = -1;
}
ast_mutex_unlock(&iaxq.lock);
AST_LIST_UNLOCK(&iaxq.queue);
memset(&ied1, 0, sizeof(ied1));
iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->callno);
send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1);
@ -8031,49 +8014,42 @@ static void *network_thread(void *ignore)
/* Our job is simple: Send queued messages, retrying if necessary. Read frames
from the network, and queue them for delivery to the channels */
int res, count;
struct iax_frame *f, *freeme;
struct iax_frame *f;
if (timingfd > -1)
ast_io_add(io, timingfd, timing_read, AST_IO_IN | AST_IO_PRI, NULL);
for(;;) {
/* Go through the queue, sending messages which have not yet been
sent, and scheduling retransmissions if appropriate */
ast_mutex_lock(&iaxq.lock);
f = iaxq.head;
AST_LIST_LOCK(&iaxq.queue);
count = 0;
while(f) {
freeme = NULL;
if (!f->sentyet) {
f->sentyet++;
/* Send a copy immediately -- errors here are ok, so don't bother locking */
if (iaxs[f->callno]) {
send_packet(f);
count++;
}
if (f->retries < 0) {
/* This is not supposed to be retransmitted */
if (f->prev)
f->prev->next = f->next;
else
iaxq.head = f->next;
if (f->next)
f->next->prev = f->prev;
else
iaxq.tail = f->prev;
iaxq.count--;
/* Free the iax frame */
freeme = f;
} else {
/* We need reliable delivery. Schedule a retransmission */
f->retries++;
f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
signal_condition(&sched_lock, &sched_cond);
}
AST_LIST_TRAVERSE_SAFE_BEGIN(&iaxq.queue, f, list) {
if (f->sentyet)
continue;
f->sentyet++;
/* Send a copy immediately -- errors here are ok, so don't bother locking */
if (iaxs[f->callno]) {
send_packet(f);
count++;
}
if (f->retries < 0) {
/* This is not supposed to be retransmitted */
AST_LIST_REMOVE(&iaxq.queue, f, list);
iaxq.count--;
/* Free the iax frame */
iax_frame_free(f);
} else {
/* We need reliable delivery. Schedule a retransmission */
f->retries++;
f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
signal_condition(&sched_lock, &sched_cond);
}
f = f->next;
if (freeme)
iax_frame_free(freeme);
}
ast_mutex_unlock(&iaxq.lock);
AST_LIST_TRAVERSE_SAFE_END
AST_LIST_UNLOCK(&iaxq.queue);
if (count >= 20)
ast_log(LOG_DEBUG, "chan_iax2: Sent %d queued outbound frames all at once\n", count);
@ -9751,7 +9727,6 @@ static int __unload_module(void)
static int unload_module(void)
{
ast_mutex_destroy(&iaxq.lock);
ast_mutex_destroy(&waresl.lock);
ast_custom_function_unregister(&iaxpeer_function);
return __unload_module();
@ -9803,7 +9778,6 @@ static int load_module(void)
}
ast_netsock_init(netsock);
ast_mutex_init(&iaxq.lock);
ast_mutex_init(&waresl.lock);
ast_cli_register_multiple(iax2_cli, sizeof(iax2_cli) / sizeof(iax2_cli[0]));

4
channels/chan_local.c
View File

@ -226,7 +226,7 @@ static void check_bridge(struct local_pvt *p, int isoutbound)
frames on the owner channel (because they would be transferred to the
outbound channel during the masquerade)
*/
if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel! Only go one step! */ && !p->owner->readq) {
if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel! Only go one step! */ && AST_LIST_EMPTY(&p->owner->readq)) {
/* Masquerade bridged channel into owner */
/* Lock everything we need, one by one, and give up if
we can't get everything. Remember, we'll get another
@ -248,7 +248,7 @@ static void check_bridge(struct local_pvt *p, int isoutbound)
when the local channels go away.
*/
#if 0
} else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && !p->chan->readq) {
} else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && AST_LIST_EMPTY(&p->chan->readq)) {
/* Masquerade bridged channel into chan */
if (!ast_mutex_trylock(&(p->owner->_bridge)->lock)) {
if (!p->owner->_bridge->_softhangup) {

3
channels/chan_zap.c
View File

@ -3516,7 +3516,6 @@ static struct ast_frame *zt_handle_event(struct ast_channel *ast)
pthread_t threadid;
pthread_attr_t attr;
struct ast_channel *chan;
struct ast_frame dtmf_frame = { .frametype = AST_FRAME_DTMF };
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
@ -3560,8 +3559,6 @@ static struct ast_frame *zt_handle_event(struct ast_channel *ast)
*/
p->subs[index].f.frametype = AST_FRAME_DTMF_BEGIN;
p->subs[index].f.subclass = res & 0xff;
dtmf_frame.subclass = res & 0xff;
p->subs[index].f.next = ast_frdup(&dtmf_frame);
#ifdef HAVE_PRI
}
#endif

82
channels/iax2-parser.c
View File

@ -40,6 +40,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/utils.h"
#include "asterisk/unaligned.h"
#include "asterisk/lock.h"
#include "asterisk/threadstorage.h"
#include "iax2.h"
#include "iax2-parser.h"
@ -49,6 +50,15 @@ static int frames = 0;
static int iframes = 0;
static int oframes = 0;
static void frame_cache_cleanup(void *data);
/*! \brief A per-thread cache of iax_frame structures */
AST_THREADSTORAGE_CUSTOM(frame_cache, frame_cache_init, frame_cache_cleanup);
/*! \brief This is just so iax_frames, a list head struct for holding a list of
* iax_frame structures, is defined. */
AST_LIST_HEAD_NOLOCK(iax_frames, iax_frame);
static void internaloutput(const char *str)
{
fputs(str, stdout);
@ -926,22 +936,44 @@ void iax_frame_wrap(struct iax_frame *fr, struct ast_frame *f)
struct iax_frame *iax_frame_new(int direction, int datalen)
{
struct iax_frame *fr;
fr = malloc((int)sizeof(struct iax_frame) + datalen);
if (fr) {
fr->direction = direction;
fr->retrans = -1;
ast_atomic_fetchadd_int(&frames, 1);
if (fr->direction == DIRECTION_INGRESS)
ast_atomic_fetchadd_int(&iframes, 1);
else
ast_atomic_fetchadd_int(&oframes, 1);
struct iax_frame *fr = NULL;
struct iax_frames *iax_frames;
/* Attempt to get a frame from this thread's cache */
if ((iax_frames = ast_threadstorage_get(&frame_cache, sizeof(*iax_frames)))) {
AST_LIST_TRAVERSE_SAFE_BEGIN(iax_frames, fr, list) {
if (fr->mallocd_datalen >= datalen) {
size_t mallocd_datalen = fr->mallocd_datalen;
AST_LIST_REMOVE_CURRENT(iax_frames, list);
memset(fr, 0, sizeof(*fr));
fr->mallocd_datalen = mallocd_datalen;
break;
}
}
AST_LIST_TRAVERSE_SAFE_END
}
if (!fr) {
if (!(fr = ast_calloc(1, sizeof(*fr) + datalen)))
return NULL;
fr->mallocd_datalen = datalen;
}
fr->direction = direction;
fr->retrans = -1;
if (fr->direction == DIRECTION_INGRESS)
ast_atomic_fetchadd_int(&iframes, 1);
else
ast_atomic_fetchadd_int(&oframes, 1);
return fr;
}
void iax_frame_free(struct iax_frame *fr)
static void __iax_frame_free(struct iax_frame *fr, int cache)
{
struct iax_frames *iax_frames;
/* Note: does not remove from scheduler! */
if (fr->direction == DIRECTION_INGRESS)
ast_atomic_fetchadd_int(&iframes, -1);
@ -952,8 +984,34 @@ void iax_frame_free(struct iax_frame *fr)
return;
}
fr->direction = 0;
free(fr);
ast_atomic_fetchadd_int(&frames, -1);
if (!cache) {
free(fr);
return;
}
if (!(iax_frames = ast_threadstorage_get(&frame_cache, sizeof(*iax_frames)))) {
free(fr);
return;
}
AST_LIST_INSERT_HEAD(iax_frames, fr, list);
}
static void frame_cache_cleanup(void *data)
{
struct iax_frames *frames = data;
struct iax_frame *cur;
while ((cur = AST_LIST_REMOVE_HEAD(frames, list)))
__iax_frame_free(cur, 0);
free(frames);
}
void iax_frame_free(struct iax_frame *fr)
{
__iax_frame_free(fr, 1);
}
int iax_get_frames(void) { return frames; }

7
channels/iax2-parser.h
View File

@ -18,6 +18,8 @@
#ifndef _IAX2_PARSER_H
#define _IAX2_PARSER_H
#include "asterisk/linkedlists.h"
struct iax_ies {
char *called_number;
char *calling_number;
@ -115,10 +117,11 @@ struct iax_frame {
/* Retransmission ID */
int retrans;
/* Easy linking */
struct iax_frame *next;
struct iax_frame *prev;
AST_LIST_ENTRY(iax_frame) list;
/* Actual, isolated frame header */
struct ast_frame af;
/*! Amount of space _allocated_ for data */
size_t mallocd_datalen;
unsigned char unused[AST_FRIENDLY_OFFSET];
unsigned char afdata[0]; /* Data for frame */
};

2
include/asterisk/channel.h
View File

@ -410,7 +410,7 @@ struct ast_channel {
unsigned int pickupgroup; /*!< Pickup group - which calls groups can be picked up? */
unsigned int flags; /*!< channel flags of AST_FLAG_ type */
unsigned short transfercapability; /*!< ISDN Transfer Capbility - AST_FLAG_DIGITAL is not enough */
struct ast_frame *readq;
AST_LIST_HEAD_NOLOCK(, ast_frame) readq;
int alertpipe[2];
int nativeformats; /*!< Kinds of data this channel can natively handle */

2
include/asterisk/chanspy.h
View File

@ -49,7 +49,7 @@ enum chanspy_flags {
};
struct ast_channel_spy_queue {
struct ast_frame *head;
AST_LIST_HEAD_NOLOCK(, ast_frame) list;
unsigned int samples;
unsigned int format;
};

9
include/asterisk/frame.h
View File

@ -32,6 +32,7 @@ extern "C" {
#include <sys/types.h>
#include <sys/time.h>
#include "asterisk/endian.h"
#include "asterisk/linkedlists.h"
struct ast_codec_pref {
char order[32];
@ -97,6 +98,8 @@ struct ast_frame {
int samples;
/*! Was the data malloc'd? i.e. should we free it when we discard the frame? */
int mallocd;
/*! The number of bytes allocated for a malloc'd frame header */
size_t mallocd_hdr_len;
/*! How many bytes exist _before_ "data" that can be used if needed */
int offset;
/*! Optional source of frame for debugging */
@ -105,10 +108,8 @@ struct ast_frame {
void *data;
/*! Global delivery time */
struct timeval delivery;
/*! Next/Prev for linking stand alone frames */
struct ast_frame *prev;
/*! Next/Prev for linking stand alone frames */
struct ast_frame *next;
/*! For placing in a linked list */
AST_LIST_ENTRY(ast_frame) frame_list;
/*! Timing data flag */
int has_timing_info;
/*! Timestamp in milliseconds */

2
include/asterisk/slinfactory.h
View File

@ -32,7 +32,7 @@ extern "C" {
#endif
struct ast_slinfactory {
struct ast_frame *queue;
AST_LIST_HEAD_NOLOCK(, ast_frame) queue;
struct ast_trans_pvt *trans;
short hold[1280];
short *offset;

5
main/abstract_jb.c
View File

@ -324,10 +324,7 @@ int ast_jb_put(struct ast_channel *chan, struct ast_frame *f)
return -1;
}
if (f->mallocd & AST_MALLOCD_HDR)
frr = ast_frdup(f);
else
frr = ast_frisolate(f);
frr = ast_frdup(f);
if (!frr) {
ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", chan->name);

157
main/channel.c
View File

@ -706,7 +706,7 @@ struct ast_channel *ast_channel_alloc(int needqueue)
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
{
struct ast_frame *f;
struct ast_frame *prev, *cur;
struct ast_frame *cur;
int blah = 1;
int qlen = 0;
@ -716,17 +716,19 @@ int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
return -1;
}
ast_channel_lock(chan);
prev = NULL;
for (cur = chan->readq; cur; cur = cur->next) {
if ((cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
/* Don't bother actually queueing anything after a hangup */
ast_frfree(f);
ast_channel_unlock(chan);
return 0;
}
prev = cur;
/* See if the last frame on the queue is a hangup, if so don't queue anything */
if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
ast_frfree(f);
ast_channel_unlock(chan);
return 0;
}
/* Count how many frames exist on the queue */
AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
qlen++;
}
/* Allow up to 96 voice frames outstanding, and up to 128 total frames */
if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen > 128)) {
if (fin->frametype != AST_FRAME_VOICE) {
@ -739,10 +741,7 @@ int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
return 0;
}
}
if (prev)
prev->next = f;
else
chan->readq = f;
AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
if (chan->alertpipe[1] > -1) {
if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
@ -973,7 +972,7 @@ void ast_channel_free(struct ast_channel *chan)
{
int fd;
struct ast_var_t *vardata;
struct ast_frame *f, *fp;
struct ast_frame *f;
struct varshead *headp;
struct ast_datastore *datastore = NULL;
char name[AST_CHANNEL_NAME];
@ -1024,13 +1023,8 @@ void ast_channel_free(struct ast_channel *chan)
close(fd);
if ((fd = chan->timingfd) > -1)
close(fd);
f = chan->readq;
chan->readq = NULL;
while(f) {
fp = f;
f = f->next;
ast_frfree(fp);
}
while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
ast_frfree(f);
/* Get rid of each of the data stores on the channel */
while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
@ -1247,14 +1241,11 @@ void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *sp
spy->chan = NULL;
for (f = spy->read_queue.head; f; f = spy->read_queue.head) {
spy->read_queue.head = f->next;
while ((f = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list)))
ast_frfree(f);
}
for (f = spy->write_queue.head; f; f = spy->write_queue.head) {
spy->write_queue.head = f->next;
while ((f = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list)))
ast_frfree(f);
}
if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
ast_cond_destroy(&spy->trigger);
@ -1337,8 +1328,6 @@ static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f,
trans = (dir == SPY_READ) ? &chan->spies->read_translator : &chan->spies->write_translator;
AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
struct ast_frame *last;
struct ast_frame *f1; /* the frame to append */
struct ast_channel_spy_queue *queue;
ast_mutex_lock(&spy->lock);
@ -1370,7 +1359,7 @@ static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f,
break;
}
}
f1 = translated_frame;
AST_LIST_INSERT_TAIL(&queue->list, ast_frdup(f), frame_list);
} else {
if (f->subclass != queue->format) {
ast_log(LOG_WARNING, "Spy '%s' on channel '%s' wants format '%s', but frame is '%s', dropping\n",
@ -1379,17 +1368,8 @@ static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f,
ast_mutex_unlock(&spy->lock);
continue;
}
f1 = f;
AST_LIST_INSERT_TAIL(&queue->list, ast_frdup(f), frame_list);
}
/* duplicate and append f1 to the tail */
f1 = ast_frdup(f1);
for (last = queue->head; last && last->next; last = last->next)
;
if (last)
last->next = f1;
else
queue->head = f1;
queue->samples += f->samples;
@ -1425,10 +1405,8 @@ static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f,
ast_log(LOG_DEBUG, "Spy '%s' on channel '%s' %s queue too long, dropping frames\n",
spy->type, chan->name, (dir == SPY_READ) ? "read" : "write");
while (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
struct ast_frame *drop = queue->head;
struct ast_frame *drop = AST_LIST_REMOVE_HEAD(&queue->list, frame_list);
queue->samples -= drop->samples;
queue->head = drop->next;
ast_frfree(drop);
}
}
@ -1946,7 +1924,7 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
blah = ZT_EVENT_TIMER_EXPIRED;
if (blah == ZT_EVENT_TIMER_PING) {
if (!chan->readq || !chan->readq->next) {
if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
/* Acknowledge PONG unless we need it again */
if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
@ -1985,10 +1963,8 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
}
/* Check for pending read queue */
if (chan->readq) {
f = chan->readq;
chan->readq = f->next;
f->next = NULL;
if (!AST_LIST_EMPTY(&chan->readq)) {
f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
/* Interpret hangup and return NULL */
/* XXX why not the same for frames from the channel ? */
if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
@ -2014,11 +1990,13 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
if (f) {
/* if the channel driver returned more than one frame, stuff the excess
into the readq for the next ast_read call
into the readq for the next ast_read call (note that we can safely assume
that the readq is empty, because otherwise we would not have called into
the channel driver and f would be only a single frame)
*/
if (f->next) {
chan->readq = f->next;
f->next = NULL;
if (AST_LIST_NEXT(f, frame_list)) {
AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
AST_LIST_NEXT(f, frame_list) = NULL;
}
switch (f->frametype) {
@ -3068,7 +3046,7 @@ int ast_do_masquerade(struct ast_channel *original)
int x,i;
int res=0;
int origstate;
struct ast_frame *cur, *prev;
struct ast_frame *cur;
const struct ast_channel_tech *t;
void *t_pvt;
struct ast_callerid tmpcid;
@ -3132,9 +3110,9 @@ int ast_do_masquerade(struct ast_channel *original)
clone->tech_pvt = t_pvt;
/* Swap the readq's */
cur = original->readq;
original->readq = clone->readq;
clone->readq = cur;
cur = AST_LIST_FIRST(&original->readq);
AST_LIST_HEAD_SET_NOLOCK(&original->readq, AST_LIST_FIRST(&clone->readq));
AST_LIST_HEAD_SET_NOLOCK(&clone->readq, cur);
/* Swap the alertpipes */
for (i = 0; i < 2; i++) {
@ -3153,23 +3131,22 @@ int ast_do_masquerade(struct ast_channel *original)
/* Save any pending frames on both sides. Start by counting
* how many we're going to need... */
prev = NULL;
x = 0;
for (cur = clone->readq; cur; cur = cur->next) {
x++;
prev = cur;
if (original->alertpipe[1] > -1) {
AST_LIST_TRAVERSE(&clone->readq, cur, frame_list)
x++;
}
/* If we had any, prepend them to the ones already in the queue, and
/* If we had any, prepend them to the ones already in the queue, and
* load up the alertpipe */
if (prev) {
prev->next = original->readq;
original->readq = clone->readq;
clone->readq = NULL;
if (original->alertpipe[1] > -1) {
for (i = 0; i < x; i++)
write(original->alertpipe[1], &x, sizeof(x));
}
if (AST_LIST_FIRST(&clone->readq)) {
AST_LIST_INSERT_TAIL(&clone->readq, AST_LIST_FIRST(&original->readq), frame_list);
AST_LIST_HEAD_SET_NOLOCK(&original->readq, AST_LIST_FIRST(&clone->readq));
AST_LIST_HEAD_SET_NOLOCK(&clone->readq, NULL);
for (i = 0; i < x; i++)
write(original->alertpipe[1], &x, sizeof(x));
}
clone->_softhangup = AST_SOFTHANGUP_DEV;
@ -4086,9 +4063,7 @@ static void copy_data_from_queue(struct ast_channel_spy_queue *queue, short *buf
int bytestocopy;
while (samples) {
f = queue->head;
if (!f) {
if (!(f = AST_LIST_FIRST(&queue->list))) {
ast_log(LOG_ERROR, "Ran out of frames before buffer filled!\n");
break;
}
@ -4103,10 +4078,9 @@ static void copy_data_from_queue(struct ast_channel_spy_queue *queue, short *buf
f->datalen -= bytestocopy;
f->offset += bytestocopy;
queue->samples -= tocopy;
if (!f->samples) {
queue->head = f->next;
ast_frfree(f);
}
if (!f->samples)
ast_frfree(AST_LIST_REMOVE_HEAD(&queue->list, frame_list));
}
}
@ -4136,19 +4110,19 @@ struct ast_frame *ast_channel_spy_read_frame(struct ast_channel_spy *spy, unsign
if (ast_test_flag(spy, CHANSPY_TRIGGER_FLUSH)) {
if (spy->read_queue.samples > spy->write_queue.samples) {
if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST)) {
for (result = spy->read_queue.head; result; result = result->next)
AST_LIST_TRAVERSE(&spy->read_queue.list, result, frame_list)
ast_frame_adjust_volume(result, spy->read_vol_adjustment);
}
result = spy->read_queue.head;
spy->read_queue.head = NULL;
result = AST_LIST_FIRST(&spy->read_queue.list);
AST_LIST_HEAD_SET_NOLOCK(&spy->read_queue.list, NULL);
spy->read_queue.samples = 0;
} else {
if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST)) {
for (result = spy->write_queue.head; result; result = result->next)
AST_LIST_TRAVERSE(&spy->write_queue.list, result, frame_list)
ast_frame_adjust_volume(result, spy->write_vol_adjustment);
}
result = spy->write_queue.head;
spy->write_queue.head = NULL;
result = AST_LIST_FIRST(&spy->write_queue.list);
AST_LIST_HEAD_SET_NOLOCK(&spy->write_queue.list, NULL);
spy->write_queue.samples = 0;
}
ast_clear_flag(spy, CHANSPY_TRIGGER_FLUSH);
@ -4159,15 +4133,10 @@ struct ast_frame *ast_channel_spy_read_frame(struct ast_channel_spy *spy, unsign
return NULL;
/* short-circuit if both head frames have exactly what we want */
if ((spy->read_queue.head->samples == samples) &&
(spy->write_queue.head->samples == samples)) {
read_frame = spy->read_queue.head;
spy->read_queue.head = read_frame->next;
read_frame->next = NULL;
write_frame = spy->write_queue.head;
spy->write_queue.head = write_frame->next;
write_frame->next = NULL;
if ((AST_LIST_FIRST(&spy->read_queue.list)->samples == samples) &&
(AST_LIST_FIRST(&spy->write_queue.list)->samples == samples)) {
read_frame = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list);
write_frame = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list);
spy->read_queue.samples -= samples;
spy->write_queue.samples -= samples;
@ -4200,10 +4169,10 @@ struct ast_frame *ast_channel_spy_read_frame(struct ast_channel_spy *spy, unsign
} else {
if (need_dup) {
result = ast_frdup(read_frame);
result->next = ast_frdup(write_frame);
AST_LIST_NEXT(result, frame_list) = ast_frdup(write_frame);
} else {
result = read_frame;
result->next = write_frame;
AST_LIST_NEXT(result, frame_list) = write_frame;
}
}

172
main/frame.c
View File

@ -41,13 +41,39 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/cli.h"
#include "asterisk/term.h"
#include "asterisk/utils.h"
#include "asterisk/threadstorage.h"
#include "asterisk/linkedlists.h"
#ifdef TRACE_FRAMES
static int headers = 0;
static struct ast_frame *headerlist = NULL;
AST_MUTEX_DEFINE_STATIC(framelock);
static AST_LIST_HEAD_STATIC(headerlist, ast_frame);
#endif
static void frame_cache_cleanup(void *data);
/*! \brief A per-thread cache of frame headers */
AST_THREADSTORAGE_CUSTOM(frame_cache, frame_cache_init, frame_cache_cleanup);
/*!
* \brief Maximum ast_frame cache size
*
* In most cases where the frame header cache will be useful, the size
* of the cache will stay very small. However, it is not always the case that
* the same thread that allocates the frame will be the one freeing them, so
* sometimes a thread will never have any frames in its cache, or the cache
* will never be pulled from. For the latter case, we limit the maximum size.
*/
#define FRAME_CACHE_MAX_SIZE 10
/*! \brief This is just so ast_frames, a list head struct for holding a list of
* ast_frame structures, is defined. */
AST_LIST_HEAD_NOLOCK(ast_frames, ast_frame);
struct ast_frame_cache {
struct ast_frames list;
size_t size;
};
#define SMOOTHER_SIZE 8000
enum frame_type {
@ -252,28 +278,63 @@ void ast_smoother_free(struct ast_smoother *s)
static struct ast_frame *ast_frame_header_new(void)
{
struct ast_frame *f = ast_calloc(1, sizeof(*f));
#ifdef TRACE_FRAMES
if (f) {
f->prev = NULL;
ast_mutex_lock(&framelock);
headers++;
f->next = headerlist;
if (headerlist)
headerlist->prev = f;
headerlist = f;
ast_mutex_unlock(&framelock);
struct ast_frame *f;
struct ast_frame_cache *frames;
if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
if ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list))) {
size_t mallocd_len = f->mallocd_hdr_len;
memset(f, 0, sizeof(*f));
f->mallocd_hdr_len = mallocd_len;
f->mallocd = AST_MALLOCD_HDR;
frames->size--;
return f;
}
}
if (!(f = ast_calloc(1, sizeof(*f))))
return NULL;
f->mallocd_hdr_len = sizeof(*f);
#ifdef TRACE_FRAMES
AST_LIST_LOCK(&headerlist);
headers++;
AST_LIST_INSERT_HEAD(&headerlist, f, frame_list);
AST_LIST_UNLOCK(&headerlist);
#endif
return f;
}
/*!
* \todo Important: I should be made more efficient. Frame headers should
* most definitely be cached
*/
static void frame_cache_cleanup(void *data)
{
struct ast_frame_cache *frames = data;
struct ast_frame *f;
while ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list)))
free(f);
free(frames);
}
void ast_frfree(struct ast_frame *fr)
{
if (!fr->mallocd)
return;
if (fr->mallocd == AST_MALLOCD_HDR) {
/* Cool, only the header is malloc'd, let's just cache those for now
* to keep things simple... */
struct ast_frame_cache *frames;
if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))
&& frames->size < FRAME_CACHE_MAX_SIZE) {
AST_LIST_INSERT_HEAD(&frames->list, fr, frame_list);
frames->size++;
return;
}
}
if (fr->mallocd & AST_MALLOCD_DATA) {
if (fr->data)
free(fr->data - fr->offset);
@ -284,15 +345,10 @@ void ast_frfree(struct ast_frame *fr)
}
if (fr->mallocd & AST_MALLOCD_HDR) {
#ifdef TRACE_FRAMES
ast_mutex_lock(&framelock);
AST_LIST_LOCK(&headerlist);
headers--;
if (fr->next)
fr->next->prev = fr->prev;
if (fr->prev)
fr->prev->next = fr->next;
else
headerlist = fr->next;
ast_mutex_unlock(&framelock);
AST_LIST_REMOVE(&headerlist, fr, frame_list);
AST_LIST_UNLOCK(&headerlist);
#endif
free(fr);
}
@ -361,9 +417,11 @@ struct ast_frame *ast_frisolate(struct ast_frame *fr)
struct ast_frame *ast_frdup(const struct ast_frame *f)
{
struct ast_frame_cache *frames;
struct ast_frame *out;
int len, srclen = 0;
void *buf;
void *buf = NULL;
/* Start with standard stuff */
len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
/* If we have a source, add space for it */
@ -375,16 +433,35 @@ struct ast_frame *ast_frdup(const struct ast_frame *f)
srclen = strlen(f->src);
if (srclen > 0)
len += srclen + 1;
if (!(buf = ast_calloc(1, len)))
return NULL;
out = buf;
/* Set us as having malloc'd header only, so it will eventually
get freed. */
if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
AST_LIST_TRAVERSE_SAFE_BEGIN(&frames->list, out, frame_list) {
if (out->mallocd_hdr_len >= len) {
size_t mallocd_len = out->mallocd_hdr_len;
AST_LIST_REMOVE_CURRENT(&frames->list, frame_list);
memset(out, 0, sizeof(*out));
out->mallocd_hdr_len = mallocd_len;
buf = out;
frames->size--;
break;
}
}
AST_LIST_TRAVERSE_SAFE_END
}
if (!buf) {
if (!(buf = ast_calloc(1, len)))
return NULL;
out = buf;
out->mallocd_hdr_len = len;
}
out->frametype = f->frametype;
out->subclass = f->subclass;
out->datalen = f->datalen;
out->samples = f->samples;
out->delivery = f->delivery;
/* Set us as having malloc'd header only, so it will eventually
get freed. */
out->mallocd = AST_MALLOCD_HDR;
out->offset = AST_FRIENDLY_OFFSET;
if (out->datalen) {
@ -860,15 +937,14 @@ static int show_frame_stats(int fd, int argc, char *argv[])
int x=1;
if (argc != 3)
return RESULT_SHOWUSAGE;
ast_mutex_lock(&framelock);
AST_LIST_LOCK(&headerlist);
ast_cli(fd, " Framer Statistics \n");
ast_cli(fd, "---------------------------\n");
ast_cli(fd, "Total allocated headers: %d\n", headers);
ast_cli(fd, "Queue Dump:\n");
for (f=headerlist; f; f = f->next) {
AST_LIST_TRAVERSE(&headerlist, f, frame_list)
ast_cli(fd, "%d. Type %d, subclass %d from %s\n", x++, f->frametype, f->subclass, f->src ? f->src : "<Unknown>");
}
ast_mutex_unlock(&framelock);
AST_LIST_UNLOCK(&headerlist);
return RESULT_SUCCESS;
}
@ -889,6 +965,7 @@ static struct ast_cli_entry my_clis[] = {
#endif
};
int init_framer(void)
{
ast_cli_register_multiple(my_clis, sizeof(my_clis)/sizeof(my_clis[0]) );
@ -1342,28 +1419,3 @@ int ast_frame_slinear_sum(struct ast_frame *f1, struct ast_frame *f2)
return 0;
}
struct ast_frame *ast_frame_enqueue(struct ast_frame *head, struct ast_frame *f, int maxlen, int dupe)
{
struct ast_frame *cur, *oldhead;
int len=0;
if (f && dupe)
f = ast_frdup(f);
if (!f)
return head;
f->next = NULL;
if (!head)
return f;
cur = head;
while(cur->next) {
cur = cur->next;
len++;
if (len >= maxlen) {
oldhead = head;
head = head->next;
ast_frfree(oldhead);
}
}
return head;
}

17
main/slinfactory.c
View File

@ -39,7 +39,6 @@ void ast_slinfactory_init(struct ast_slinfactory *sf)
{
memset(sf, 0, sizeof(*sf));
sf->offset = sf->hold;
sf->queue = NULL;
}
void ast_slinfactory_destroy(struct ast_slinfactory *sf)
@ -51,10 +50,8 @@ void ast_slinfactory_destroy(struct ast_slinfactory *sf)
sf->trans = NULL;
}
while ((f = sf->queue)) {
sf->queue = f->next;
while ((f = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list)))
ast_frfree(f);
}
}
int ast_slinfactory_feed(struct ast_slinfactory *sf, struct ast_frame *f)
@ -85,15 +82,12 @@ int ast_slinfactory_feed(struct ast_slinfactory *sf, struct ast_frame *f)
if (!frame)
return 0;
for (x = 0, frame_ptr = sf->queue; frame_ptr && frame_ptr->next; frame_ptr = frame_ptr->next)
x = 0;
AST_LIST_TRAVERSE(&sf->queue, frame_ptr, frame_list)
x++;
if (frame_ptr)
frame_ptr->next = frame;
else
sf->queue = frame;
AST_LIST_INSERT_TAIL(&sf->queue, frame, frame_list);
frame->next = NULL;
sf->size += frame->samples;
return x;
@ -125,8 +119,7 @@ int ast_slinfactory_read(struct ast_slinfactory *sf, short *buf, size_t samples)
continue;
}
if ((frame_ptr = sf->queue)) {
sf->queue = frame_ptr->next;
if ((frame_ptr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list))) {
frame_data = frame_ptr->data;
if ((sofar + frame_ptr->samples) <= ineed) {

35
main/udptl.c
View File

@ -296,8 +296,7 @@ static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
ptr = 0;
ifp_no = 0;
s->f[0].prev = NULL;
s->f[0].next = NULL;
memset(&s->f[0], 0, sizeof(s->f[0]));
/* Decode seq_number */
if (ptr + 2 > len)
@ -342,11 +341,9 @@ static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
s->f[ifp_no].data = (uint8_t *) bufs[i - 1];
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0) {
s->f[ifp_no].prev = &s->f[ifp_no - 1];
s->f[ifp_no - 1].next = &s->f[ifp_no];
}
s->f[ifp_no].next = NULL;
if (ifp_no > 0)
AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
ifp_no++;
}
}
@ -364,11 +361,9 @@ static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
s->f[ifp_no].data = (uint8_t *) ifp;
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0) {
s->f[ifp_no].prev = &s->f[ifp_no - 1];
s->f[ifp_no - 1].next = &s->f[ifp_no];
}
s->f[ifp_no].next = NULL;
if (ifp_no > 0)
AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
}
}
else
@ -465,11 +460,9 @@ static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
s->f[ifp_no].data = s->rx[l].buf;
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0) {
s->f[ifp_no].prev = &s->f[ifp_no - 1];
s->f[ifp_no - 1].next = &s->f[ifp_no];
}
s->f[ifp_no].next = NULL;
if (ifp_no > 0)
AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
ifp_no++;
}
}
@ -483,11 +476,9 @@ static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
s->f[ifp_no].data = (uint8_t *) ifp;
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0) {
s->f[ifp_no].prev = &s->f[ifp_no - 1];
s->f[ifp_no - 1].next = &s->f[ifp_no];
}
s->f[ifp_no].next = NULL;
if (ifp_no > 0)
AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
}
s->rx_seq_no = seq_no + 1;