/** send out waiting packets */
static void
service_send(struct ringbuf* ring, struct timeval* now, sldns_buffer* pkt,
struct sockaddr_storage* srv_addr, socklen_t srv_len)
{
struct proxy* p;
struct timeval tv;
ssize_t sent;
while(!ring_empty(ring) &&
dl_tv_smaller(ring_peek_time(ring), now)) {
/* this items needs to be sent out */
if(!ring_pop(ring, pkt, &tv, &p))
fatal_exit("ringbuf error: pop failed");
verbose(1, "send out query %d.%6.6d",
(unsigned)tv.tv_sec, (unsigned)tv.tv_usec);
log_addr(1, "from client", &p->addr, p->addr_len);
/* send it */
sent = sendto(p->s, (void*)sldns_buffer_begin(pkt),
sldns_buffer_limit(pkt), 0,
(struct sockaddr*)srv_addr, srv_len);
if(sent == -1) {
#ifndef USE_WINSOCK
log_err("sendto: %s", strerror(errno));
#else
log_err("sendto: %s", wsa_strerror(WSAGetLastError()));
#endif
} else if(sent != (ssize_t)sldns_buffer_limit(pkt)) {
log_err("sendto: partial send");
}
p->lastuse = *now;
p->numsent++;
}
}
/******************************************************************************
**函数名称: slot_alloc
**功 能: 申请内存块
**输入参数:
** slot: 内存块对象
** size: 申请空间大小
**输出参数: NONE
**返 回: VOID
**实现描述: 内存地址
**注意事项: 当申请的空间超过内存块的大小时，返回NULL
**作 者: # Qifeng.zou # 2015.05.05 #
******************************************************************************/
void *slot_alloc(slot_t *slot, int size)
{
if (size > slot->size) {
return NULL;
}
return ring_pop(slot->ring); /* 申请内存 */
}
static int hone_release(struct inode *inode, struct file *file)
{
struct hone_reader *reader = file->private_data;
struct hone_event *event;
hone_notifier_unregister(&reader->nb);
file->private_data = NULL;
while ((event = ring_pop(&reader->ringbuf)))
put_hone_event(event);
if (reader->filter_sk) {
sock_put(reader->filter_sk);
reader->filter_sk = NULL;
}
free_initial_events(reader);
free_hone_reader(reader);
module_put(THIS_MODULE);
return 0;
}
int
main()
{
//set buffer size as 5, first push 3 elements, and then pop 2 elements, then push 6 elements, at last pop 12 elements
const int buffer_size = 5;
int push_size_1 = 3;
int pop_size_1 = 2;
int push_size_2 = 6;
int pop_size_2 = 12;
void* data[buffer_size];
void* pop_data;
struct ring* ring_buffer = ring_create( buffer_size );
int i;
for( i = 0; i < push_size_1 ; i++){
data[i] = malloc(sizeof(int));
int err = ring_push(ring_buffer, &data[i]);
if ( err == 0 ){
printf("push data %d = %d \n", i, &data[i]);
}
else{
printf("push %d failed \n ", i);
}
}
for( i = 0; i < pop_size_1 ; i++){
pop_data = ring_pop(ring_buffer);
if(pop_data == NULL){
printf("pop %d failed \n" , i);
}
else{
printf("pop data %d = %d\n", i, pop_data);
}
}
for( i = 0; i < push_size_2 ; i++){
data[i] = malloc(sizeof(int));
int err = ring_push(ring_buffer, &data[i]);
if ( err == 0 ){
printf("push data %d = %d \n", i, &data[i]);
}
else{
printf("push %d failed \n ", i);
}
}
for( i = 0; i < pop_size_2 ; i++){
pop_data = ring_pop(ring_buffer);
if(pop_data == NULL){
printf("pop %d failed \n" , i);
}
else{
printf("pop data %d = %d\n", i, pop_data);
}
}
return 0;
}
static ssize_t hone_read(struct file *file, char __user *buffer,
size_t length, loff_t *offset)
{
struct hone_reader *reader = file->private_data;
size_t n, copied = 0;
if (!length)
return 0;
do {
while (!reader->offset && reader_will_block(reader)) {
if (file->f_flags & O_NONBLOCK)
return -EAGAIN;
if (wait_event_interruptible(reader->event_wait_queue,
!reader_will_block(reader)))
return -EINTR;
}
if (file->f_flags & O_NONBLOCK) {
if (down_trylock(&reader->sem))
return -EAGAIN;
} else if (down_interruptible(&reader->sem)) {
return -EINTR;
}
while (copied < length) {
if (!reader->offset) {
int flags;
struct hone_event *event;
void (*free_event)(struct hone_event *);
flags = atomic_read(&reader->flags);
if (flags & READER_TAIL) {
atomic_clear_mask(READER_TAIL, &reader->flags);
event = &tail_event;
free_event = NULL;
} else if (flags & READER_FINISH) {
if (!copied)
atomic_clear_mask(READER_FINISH, &reader->flags);
up(&reader->sem);
return copied;
} else if (flags & READER_HEAD) {
atomic_clear_mask(READER_HEAD, &reader->flags);
event = &head_event;
free_event = NULL;
} else if (flags & READER_INIT) {
atomic_clear_mask(READER_INIT, &reader->flags);
add_initial_events(reader);
continue;
} else if (reader->event) {
if ((event = reader->event))
reader->event = event->next;
free_event = free_hone_event;
} else {
event = ring_pop(&reader->ringbuf);
free_event = put_hone_event;
}
if (!event)
break;
reader->length = reader->format(&devinfo, &reader->info,
event, reader->buf, READ_BUFFER_SIZE);
inc_stats_counter(&reader->info.delivered, event->type);
if (free_event)
free_event(event);
}
n = min(reader->length - reader->offset, length - copied);
if (copy_to_user(buffer + copied, reader->buf + reader->offset, n)) {
up(&reader->sem);
return -EFAULT;
}
copied += n;
reader->offset += n;
if (reader->offset >= reader->length)
reader->offset = 0;
}
up(&reader->sem);
} while (!copied);
return copied;
}
/* ------------------------------------------------------------------
* Pop a character off the rx buffer
* ------------------------------------------------------------------ */
uint8_t uart_rx_pop() {
return ring_pop(&rx);
}
