* @filtid: the possible CAN message identifiers filter.
* @filtmask: the filter mask, the comparison considers only
* @filtid bits corresponding to set bits in the @filtmask field.
- * @inpeers: the lists of all peer FIFOs connected by their
+ * @inpeers: the lists of all peers FIFOs connected by their
* input side (@inends) to the same terminal (@struct canque_ends_t).
- * @outpeers: the lists of all peer FIFOs connected by their
+ * @outpeers: the lists of all peers FIFOs connected by their
* output side (@outends) to the same terminal (@struct canque_ends_t).
+ * @activepeers: the lists of peers FIFOs connected by their
+ * output side (@outends) to the same terminal (@struct canque_ends_t)
+ * with same priority and active state.
* @inends: the pointer to the FIFO input side terminal (@struct canque_ends_t).
* @outends: the pointer to the FIFO output side terminal (@struct canque_ends_t).
* @edge_used: the atomic usage counter, mainly used for safe destruction of the edge.
unsigned long filtmask;
struct list_head inpeers;
struct list_head outpeers;
+ struct list_head activepeers;
struct canque_ends_t *inends;
struct canque_ends_t *outends;
atomic_t edge_used;
struct list_head active[CANQUEUE_PRIO_NR];
struct list_head idle;
struct list_head inlist;
+ struct list_head outlist;
spinlock_t ends_lock; /* spin_lock_irqsave / spin_lock_irqrestore */
void (*notify)(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what);
void *context;
spin_lock(&outends->ends_lock);
spin_lock(&qedge->fifo.fifo_lock);
if(!canque_fifo_test_fl(&qedge->fifo,EMPTY)){
- list_del(&qedge->outpeers);
- list_add_tail(&qedge->outpeers,&outends->active[qedge->edge_prio]);
+ list_del(&qedge->activepeers);
+ list_add_tail(&qedge->activepeers,&outends->active[qedge->edge_prio]);
}
spin_unlock(&qedge->fifo.fifo_lock);
spin_unlock(&outends->ends_lock);
int canqueue_ends_init_gen(struct canque_ends_t *qends);
+void canqueue_block_inlist(struct canque_ends_t *qends);
+
+void canqueue_block_outlist(struct canque_ends_t *qends);
/* edge reference and traversal functions */
#define canque_for_each_inedge(qends, edge) \
for(edge=canque_first_inedge(qends);edge;edge=canque_next_inedge(qends, edge))
+static inline
+struct canque_edge_t *canque_first_outedge(struct canque_ends_t *qends)
+{
+ unsigned long flags;
+ struct list_head *entry;
+ struct canque_edge_t *edge;
+
+ spin_lock_irqsave(&qends->ends_lock, flags);
+ entry=qends->outlist.next;
+ skip_dead:
+ if(entry != &qends->outlist) {
+ edge=list_entry(entry,struct canque_edge_t,outpeers);
+ if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
+ entry=entry->next;
+ goto skip_dead;
+ }
+ canque_edge_incref(edge);
+ } else {
+ edge=NULL;
+ }
+ spin_unlock_irqrestore(&qends->ends_lock, flags);
+ return edge;
+}
+
+
+static inline
+struct canque_edge_t *canque_next_outedge(struct canque_ends_t *qends, struct canque_edge_t *edge)
+{
+ unsigned long flags;
+ struct list_head *entry;
+ struct canque_edge_t *next;
+
+ spin_lock_irqsave(&qends->ends_lock, flags);
+ entry=edge->outpeers.next;
+ skip_dead:
+ if(entry != &qends->outlist) {
+ next=list_entry(entry,struct canque_edge_t,outpeers);
+ if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
+ entry=entry->next;
+ goto skip_dead;
+ }
+ canque_edge_incref(next);
+ } else {
+ next=NULL;
+ }
+ spin_unlock_irqrestore(&qends->ends_lock, flags);
+ canque_edge_decref(edge);
+ return next;
+}
+
+#define canque_for_each_outedge(qends, edge) \
+ for(edge=canque_first_outedge(qends);edge;edge=canque_next_outedge(qends, edge))
+
/* Linux kernel specific functions */
struct canque_edge_t *canque_new_edge_kern(int slotsnr);
struct canque_edge_t *qedge;
struct canque_ends_t *qends;
struct list_head *entry;
- int i;
while((qedge=canque_dead_edges_cut_first())){
DEBUGQUE("edge %d disposed\n",qedge->edge_num);
entry=entry->next;
if(!list_empty(&qends->inlist))
continue;
- if(!list_empty(&qends->idle))
+ if(!list_empty(&qends->outlist))
continue;
- for(i=CANQUEUE_PRIO_NR;i--;)
- if(!list_empty(&qends->active[i]))
- continue;
spin_lock_irqsave(&canque_dead_func_lock, flags);
list_del(&qends->dead_peers);
spin_unlock_irqrestore(&canque_dead_func_lock,flags);
return qedge;
}
+#ifdef USE_DELAYED_DISCONNECT_EDGE_KERN
+
/**
* canqueue_disconnect_edge_kern - disconnect edge from communicating entities with wait
* @qends: ends structure belonging to calling communication object
}
}
-void canqueue_block_list(struct canque_ends_t *qends, struct list_head *list)
-{
- struct canque_edge_t *edge;
- struct list_head *entry;
-
- /* has to be called with qends->ends_lock already locked */
- list_for_each(entry,&qends->inlist){
- if(list == &qends->inlist)
- edge=list_entry(list->next,struct canque_edge_t,inpeers);
- else
- edge=list_entry(list->next,struct canque_edge_t,outpeers);
- canque_fifo_set_fl(&edge->fifo,BLOCK);
- }
-}
+#endif /*USE_DELAYED_DISCONNECT_EDGE_KERN*/
+
int canqueue_ends_sync_all_kern(struct canque_ends_t *qends)
{
}
+int canqueue_ends_done_outends(struct canque_ends_t *qends)
+{
+ struct canque_edge_t *edge;
+
+ canque_for_each_outedge(qends, edge){
+ canque_notify_bothends(edge, CANQUEUE_NOTIFY_DEAD_WANTED);
+ }
+ return list_empty(&qends->outlist)?0:1;
+}
+
+
/**
* canqueue_ends_dispose_kern - finalizing of the ends structure for Linux kernel clients
* @qends: pointer to ends structure
int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync)
{
unsigned long flags;
- int i;
int delayed;
DEBUGQUE("canqueue_ends_dispose_kern\n");
- spin_lock_irqsave(&qends->ends_lock,flags);
- canqueue_block_list(qends, &qends->idle);
- for(i=CANQUEUE_PRIO_NR;--i>=0;){
- canqueue_block_list(qends, &qends->active[i]);
- }
- canqueue_block_list(qends, &qends->idle);
- canqueue_block_list(qends, &qends->inlist);
- spin_unlock_irqrestore(&qends->ends_lock,flags);
+ canqueue_block_inlist(qends);
+ canqueue_block_outlist(qends);
/*Wait for sending of all pending messages in the output FIFOs*/
if(sync)
/* Finish all outgoing edges listed in inends */
delayed=canqueue_ends_done_inends(qends, 1);
- delayed|=canqueue_disconnect_list_kern(qends, &qends->idle);
- for(i=CANQUEUE_PRIO_NR;--i>=0;){
- delayed|=canqueue_disconnect_list_kern(qends, &qends->active[i]);
- }
+ delayed|=canqueue_ends_done_outends(qends);
wake_up(&qends->endinfo.fileinfo.readq);
wake_up(&qends->endinfo.fileinfo.writeq);
spin_lock_irqsave(&qends->ends_lock, flags);
for(prio=CANQUEUE_PRIO_NR;--prio>=0;){
while(!list_empty(&qends->active[prio])){
- edge=list_entry(qends->active[prio].next,struct canque_edge_t,outpeers);
+ edge=list_entry(qends->active[prio].next,struct canque_edge_t,activepeers);
if(!canque_fifo_test_fl(&edge->fifo,DEAD)) {
canque_edge_incref(edge);
spin_unlock_irqrestore(&qends->ends_lock, flags);
}
spin_lock(&edge->fifo.fifo_lock);
if(canque_fifo_test_and_set_fl(&edge->fifo,INACTIVE)) {
- list_del(&edge->outpeers);
- list_add(&edge->outpeers,&qends->idle);
+ list_del(&edge->activepeers);
+ list_add(&edge->activepeers,&qends->idle);
}
spin_unlock(&edge->fifo.fifo_lock);
}
spin_lock(&qedge->fifo.fifo_lock);
if(canque_fifo_test_fl(&qedge->fifo,EMPTY)){
canque_fifo_set_fl(&qedge->fifo,INACTIVE);
- list_del(&qedge->outpeers);
- list_add(&qedge->outpeers,&qends->idle);
+ list_del(&qedge->activepeers);
+ list_add(&qedge->activepeers,&qends->idle);
} else{
- list_del(&qedge->outpeers);
- list_add_tail(&qedge->outpeers,&qends->active[qedge->edge_prio]);
+ list_del(&qedge->activepeers);
+ list_add_tail(&qedge->activepeers,&qends->active[qedge->edge_prio]);
}
spin_unlock(&qedge->fifo.fifo_lock);
}
spin_lock_irqsave(&qedge->outends->ends_lock, flags);
spin_lock(&qedge->fifo.fifo_lock);
if(canque_fifo_test_fl(&qedge->fifo,EMPTY)){
- list_del(&qedge->outpeers);
- list_add(&qedge->outpeers,&qedge->outends->idle);
+ list_del(&qedge->activepeers);
+ list_add(&qedge->activepeers,&qedge->outends->idle);
}
spin_unlock(&qedge->fifo.fifo_lock);
spin_unlock_irqrestore(&qedge->outends->ends_lock, flags);
}
INIT_LIST_HEAD(&qends->idle);
INIT_LIST_HEAD(&qends->inlist);
+ INIT_LIST_HEAD(&qends->outlist);
spin_lock_init(&qends->ends_lock);
return 0;
}
qedge->inends=inends;
list_add(&qedge->inpeers,&inends->inlist);
qedge->outends=outends;
- list_add(&qedge->outpeers,&outends->idle);
+ list_add(&qedge->outpeers,&outends->outlist);
+ list_add(&qedge->activepeers,&outends->idle);
spin_unlock(&qedge->fifo.fifo_lock);
spin_unlock(&outends->ends_lock);
spin_unlock_irqrestore(&inends->ends_lock, flags);
spin_lock(&qedge->fifo.fifo_lock);
if(atomic_read(&qedge->edge_used)==0) {
if(qedge->outends){
+ list_del(&qedge->activepeers);
+ mb(); /* memory barrier for list_empty use in canque_dead_func */
list_del(&qedge->outpeers);
qedge->outends=NULL;
}
return ret;
}
+
+/**
+ * canqueue_block_inlist - block slot allocation of all outgoing edges of specified ends
+ * @qends: pointer to ends structure
+ */
+void canqueue_block_inlist(struct canque_ends_t *qends)
+{
+ struct canque_edge_t *edge;
+
+ canque_for_each_inedge(qends, edge) {
+ canque_fifo_set_fl(&edge->fifo,BLOCK);
+ }
+}
+
+
+/**
+ * canqueue_block_outlist - block slot allocation of all incoming edges of specified ends
+ * @qends: pointer to ends structure
+ */
+void canqueue_block_outlist(struct canque_ends_t *qends)
+{
+ struct canque_edge_t *edge;
+
+ canque_for_each_outedge(qends, edge) {
+ canque_fifo_set_fl(&edge->fifo,BLOCK);
+ }
+}
+
+