X-Git-Url: http://rtime.felk.cvut.cz/gitweb/lincan.git/blobdiff_plain/91dfab84182937b62ef64cb12d8e4f89e6d5c3ec..c759ac4ffabb78a8863d9bced695980077eeb319:/lincan/src/can_queue.c diff --git a/lincan/src/can_queue.c b/lincan/src/can_queue.c index c0f1a6d..d90b9c5 100644 --- a/lincan/src/can_queue.c +++ b/lincan/src/can_queue.c @@ -3,7 +3,7 @@ * New CAN queues by Pavel Pisa - OCERA team member * email:pisa@cmp.felk.cvut.cz * This software is released under the GPL-License. - * Version lincan-0.2 9 Jul 2003 + * Version lincan-0.3 17 Jun 2004 */ #include "../include/can.h" @@ -21,9 +21,10 @@ extern int processlocal; atomic_t edge_num_cnt; //#define CAN_DEBUG +#undef CAN_DEBUG #ifdef CAN_DEBUG - #define DEBUGQUE(fmt,args...) printk(KERN_ERR "can_queue (debug): " fmt,\ + #define DEBUGQUE(fmt,args...) can_printk(KERN_ERR "can_queue (debug): " fmt,\ ##args) #else @@ -65,21 +66,17 @@ int canque_fifo_flush_slots(struct canque_fifo_t *fifo) /** - * canque_fifo_init_slots - initialize one CAN FIFO + * canque_fifo_init_slots - initializes slot chain of one CAN FIFO * @fifo: pointer to the FIFO structure - * @slotsnr: number of requested slots * * Return Value: The negative value indicates, that there is no memory * to allocate space for the requested number of the slots. */ -int canque_fifo_init_slots(struct canque_fifo_t *fifo, int slotsnr) +int canque_fifo_init_slots(struct canque_fifo_t *fifo) { - int size; struct canque_slot_t *slot; - if(!slotsnr) slotsnr=MAX_BUF_LENGTH; - size=sizeof(struct canque_slot_t)*slotsnr; - fifo->entry=kmalloc(size,GFP_KERNEL); - if(!fifo->entry) return -1; + int slotsnr=fifo->slotsnr; + if(!fifo->entry || !slotsnr) return -1; slot=fifo->entry; fifo->flist=slot; while(--slotsnr){ @@ -93,18 +90,6 @@ int canque_fifo_init_slots(struct canque_fifo_t *fifo, int slotsnr) return 1; } -/** - * canque_fifo_done - frees slots allocated for CAN FIFO - * @fifo: pointer to the FIFO structure - */ -int canque_fifo_done(struct canque_fifo_t *fifo) -{ - if(fifo->entry) - kfree(fifo->entry); - fifo->entry=NULL; - return 1; -} - /* atomic_dec_and_test(&qedge->edge_used); void atomic_inc(&qedge->edge_used); list_add_tail(struct list_head *new, struct list_head *head) @@ -112,6 +97,11 @@ int canque_fifo_done(struct canque_fifo_t *fifo) list_entry(ptr, type, member) */ +void __canque_edge_decref(struct canque_edge_t *edge) +{ + __canque_edge_decref_body(edge); +} + /** * canque_get_inslot - finds one outgoing edge and allocates slot from it * @qends: ends structure belonging to calling communication object @@ -328,6 +318,20 @@ int canque_test_outslot(struct canque_ends_t *qends, while(!list_empty(&qends->active[prio])){ edge=list_entry(qends->active[prio].next,struct canque_edge_t,activepeers); if(!canque_fifo_test_fl(&edge->fifo,DEAD)) { + /* The first test on unlocked FIFO */ + if(canque_fifo_test_fl(&edge->fifo,EMPTY)) { + can_spin_lock(&edge->fifo.fifo_lock); + /* Test has to be repeated to ensure that EMPTY + state has not been nagated when locking FIFO */ + if(canque_fifo_test_fl(&edge->fifo,EMPTY)) { + canque_fifo_set_fl(&edge->fifo,INACTIVE); + list_del(&edge->activepeers); + list_add(&edge->activepeers,&qends->idle); + can_spin_unlock(&edge->fifo.fifo_lock); + continue; + } + can_spin_unlock(&edge->fifo.fifo_lock); + } canque_edge_incref(edge); can_spin_unlock_irqrestore(&qends->ends_lock, flags); *qedgep=edge; @@ -335,14 +339,16 @@ int canque_test_outslot(struct canque_ends_t *qends, ret=canque_fifo_test_outslot(&edge->fifo, slotp); if(ret>=0) return ret; + + canque_edge_decref(edge); can_spin_lock_irqsave(&qends->ends_lock, flags); - } - can_spin_lock(&edge->fifo.fifo_lock); - if(canque_fifo_test_and_set_fl(&edge->fifo,INACTIVE)) { + } else { + can_spin_lock(&edge->fifo.fifo_lock); + canque_fifo_set_fl(&edge->fifo,INACTIVE); list_del(&edge->activepeers); list_add(&edge->activepeers,&qends->idle); + can_spin_unlock(&edge->fifo.fifo_lock); } - can_spin_unlock(&edge->fifo.fifo_lock); } } can_spin_unlock_irqrestore(&qends->ends_lock, flags); @@ -492,6 +498,7 @@ int canque_flush(struct canque_edge_t *qedge) int canqueue_ends_init_gen(struct canque_ends_t *qends) { int i; + qends->ends_flags=0; for(i=CANQUEUE_PRIO_NR;--i>=0;){ INIT_LIST_HEAD(&qends->active[i]); } @@ -517,8 +524,7 @@ int canqueue_connect_edge(struct canque_edge_t *qedge, struct canque_ends_t *ine if(qedge == NULL) return -1; DEBUGQUE("canqueue_connect_edge %d\n",qedge->edge_num); canque_edge_incref(qedge); - can_spin_lock_irqsave(&inends->ends_lock, flags); - can_spin_lock(&outends->ends_lock); + flags=canque_edge_lock_both_ends(inends, outends); can_spin_lock(&qedge->fifo.fifo_lock); qedge->inends=inends; list_add(&qedge->inpeers,&inends->inlist); @@ -526,8 +532,7 @@ int canqueue_connect_edge(struct canque_edge_t *qedge, struct canque_ends_t *ine list_add(&qedge->outpeers,&outends->outlist); list_add(&qedge->activepeers,&outends->idle); can_spin_unlock(&qedge->fifo.fifo_lock); - can_spin_unlock(&outends->ends_lock); - can_spin_unlock_irqrestore(&inends->ends_lock, flags); + canque_edge_unlock_both_ends(inends, outends, flags); canque_notify_bothends(qedge, CANQUEUE_NOTIFY_ATTACH); if(canque_fifo_test_and_set_fl(&qedge->fifo, READY)) @@ -549,9 +554,17 @@ int canqueue_disconnect_edge(struct canque_edge_t *qedge) struct canque_ends_t *inends, *outends; inends=qedge->inends; - if(inends) can_spin_lock_irqsave(&inends->ends_lock,flags); outends=qedge->outends; - if(outends) can_spin_lock(&outends->ends_lock); + + if(inends && outends) { + flags=canque_edge_lock_both_ends(inends, outends); + } else { + DEBUGQUE("canqueue_disconnect_edge called with not fully connected edge"); + if(inends) can_spin_lock_irqsave(&inends->ends_lock,flags); + if(outends) can_spin_lock(&outends->ends_lock); + flags=0; + } + can_spin_lock(&qedge->fifo.fifo_lock); if(atomic_read(&qedge->edge_used)==0) { if(qedge->outends){ @@ -567,8 +580,14 @@ int canqueue_disconnect_edge(struct canque_edge_t *qedge) ret=1; } else ret=-1; can_spin_unlock(&qedge->fifo.fifo_lock); - if(outends) can_spin_unlock(&outends->ends_lock); - if(inends) can_spin_unlock_irqrestore(&inends->ends_lock,flags); + + if(inends && outends) { + canque_edge_unlock_both_ends(inends, outends, flags); + } else { + if(outends) can_spin_unlock(&outends->ends_lock); + if(inends) can_spin_unlock_irqrestore(&inends->ends_lock,flags); + } + DEBUGQUE("canqueue_disconnect_edge %d returned %d\n",qedge->edge_num,ret); return ret; } @@ -650,4 +669,82 @@ int canqueue_ends_kill_outlist(struct canque_ends_t *qends) } +/** + * canqueue_ends_filt_conjuction - computes conjunction of incoming edges filters filters + * @qends: pointer to ends structure + * @filt: pointer the filter structure filled by computed filters conjunction + * + * Return Value: Number of incoming edges + */ +int canqueue_ends_filt_conjuction(struct canque_ends_t *qends, struct canfilt_t *filt) +{ + struct canque_edge_t *edge; + int cnt=0; + unsigned long filtid=0; + unsigned long filtmask=~0; + unsigned long local_only=canque_filtid2internal(0,MSG_LOCAL); + + canque_for_each_inedge(qends, edge){ + /* skip edges processing only local messages */ + if(edge->filtid & edge->filtmask & local_only) + continue; + + if(!cnt++) + filtid = edge->filtid; + else + filtmask &= ~(filtid ^ edge->filtid); + + filtmask &= edge->filtmask; + } + + filt->id = filtid & MSG_ID_MASK; + filt->mask = filtmask & MSG_ID_MASK; + filtid >>= 28; + filtmask >>= 28; + filt->flags = filtid & MSG_EXT; + if(filtmask & (MSG_EXT)) + filt->flags |= MSG_EXT_MASK; + if(filtid & (MSG_RTR<<1)) + filt->flags |= MSG_RTR<<1; + if(filtmask & (MSG_RTR<<1)) + filt->flags |= MSG_RTR_MASK; + return cnt; +} + + +/** + * canqueue_ends_flush_inlist - flushes all messages in incoming edges + * @qends: pointer to ends structure + * + * Return Value: Negative value informs about unsuccessful result + */ +int canqueue_ends_flush_inlist(struct canque_ends_t *qends) +{ + struct canque_edge_t *edge; + + canque_for_each_inedge(qends, edge){ + canque_flush(edge); + } + return 0; +} + + +/** + * canqueue_ends_flush_outlist - flushes all messages in outgoing edges + * @qends: pointer to ends structure + * + * Return Value: Negative value informs about unsuccessful result + */ +int canqueue_ends_flush_outlist(struct canque_ends_t *qends) +{ + struct canque_edge_t *edge; + + canque_for_each_outedge(qends, edge){ + canque_flush(edge); + } + return 0; +} + + +