| /linux/virt/lib/ |
| H A D | irqbypass.c | 56 cons->producer = prod; in __connect()
81 cons->producer = NULL; in __disconnect()
85 * irq_bypass_register_producer - register IRQ bypass producer
86 * @producer: pointer to producer structure
87 * @eventfd: pointer to the eventfd context associated with the producer
88 * @irq: Linux IRQ number of the underlying producer device
90 * Add the provided IRQ producer to the set of producers and connect with the
93 int irq_bypass_register_producer(struct irq_bypass_producer *producer, in irq_bypass_register_producer() argument
100 if (WARN_ON_ONCE(producer->eventfd)) in irq_bypass_register_producer()
103 producer->irq = irq; in irq_bypass_register_producer()
[all …]
|
| /linux/include/linux/ |
| H A D | irqbypass.h | 23 * When a producer and consumer are paired, i.e. an eventfd match is found, the
28 * the @add_* callbacks. eventfds must be unique per producer/consumer, 1:N
35 * struct irq_bypass_producer - IRQ bypass producer definition
38 * @irq: Linux IRQ number for the producer device
39 * @add_consumer: Connect the IRQ producer to an IRQ consumer (optional)
40 * @del_consumer: Disconnect the IRQ producer from an IRQ consumer (optional)
44 * The IRQ bypass producer structure represents an interrupt source for
63 * @producer: The connected producer (NULL if no connection)
64 * @add_producer: Connect the IRQ consumer to an IRQ producer
65 * @del_producer: Disconnect the IRQ consumer from an IRQ producer
[all …]
|
| /linux/net/xdp/ |
| H A D | xsk_queue.h | 17 u32 producer ____cacheline_aligned_in_smp;
19 * pointer if the producer pointer is touched and vice versa.
59 * completion ring, the kernel is the producer and user space is the
61 * user space is the producer.
63 * producer consumer
65 * if (LOAD ->consumer) { (A) LOAD.acq ->producer (C)
67 * STORE.rel ->producer (B) STORE.rel ->consumer (D)
73 * the producer pointer. If this barrier was missing, the consumer
74 * could observe the producer pointer being set and thus load the data
75 * before the producer has written the new data. The consumer would in
[all …]
|
| /linux/Documentation/core-api/ |
| H A D | circular-buffers.rst | 15 (2) Memory barriers for when the producer and the consumer of objects in the
19 producer and just one consumer. It is possible to handle multiple producers by
30 - The producer.
41 (1) A 'head' index - the point at which the producer inserts items into the
113 (1) CIRC_SPACE*() are intended to be used in the producer. To the producer
114 they will return a lower bound as the producer controls the head index,
118 To the consumer it will show an upper bound as the producer may be busy
123 producer may still be filling the buffer on another CPU and moving the
126 To the producer it will show an upper bound as the consumer may be busy
130 producer and consumer become visible cannot be guaranteed as they are
[all …]
|
| /linux/drivers/mmc/host/ |
| H A D | mmci_qcom_dml.c | 59 /* Read operation: configure DML for producer operation */ in qcom_dma_start()
60 /* Set producer CRCI-x and disable consumer CRCI */ in qcom_dma_start()
66 /* Set the Producer BAM block size */ in qcom_dma_start()
69 /* Set Producer BAM Transaction size */ in qcom_dma_start()
72 /* Set Producer Transaction End bit */ in qcom_dma_start()
76 /* Trigger producer */ in qcom_dma_start()
80 /* Set consumer CRCI-x and disable producer CRCI*/ in qcom_dma_start()
85 /* Clear Producer Transaction End bit */ in qcom_dma_start()
142 /* Disable the producer and consumer CRCI */ in qcom_dma_setup()
164 * Initialize the logical BAM pipe size for producer in qcom_dma_setup()
[all …]
|
| /linux/tools/testing/selftests/bpf/benchs/ |
| H A D | run_bench_ringbufs.sh | 9 header "Single-producer, parallel producer"
14 header "Single-producer, parallel producer, sampled notification"
19 header "Single-producer, back-to-back mode"
42 header "Single-producer, consumer/producer competing on the same CPU, low batch count"
47 header "Ringbuf, multi-producer contention"
|
| H A D | bench_rename.c | 17 fprintf(stderr, "benchmark doesn't support multi-producer!\n"); in validate()
26 static void *producer(void *input) in producer() function
113 .producer_thread = producer,
123 .producer_thread = producer,
133 .producer_thread = producer,
143 .producer_thread = producer,
153 .producer_thread = producer,
163 .producer_thread = producer,
|
| H A D | bench_local_storage.c | 74 fprintf(stderr, "benchmark doesn't support multi-producer!\n"); in validate()
233 static void *producer(void *input) in producer() function
256 .producer_thread = producer,
267 .producer_thread = producer,
278 .producer_thread = producer,
|
| H A D | bench_bloom_filter_map.c | 122 static void *producer(void *input) in producer() function
429 .producer_thread = producer,
440 .producer_thread = producer,
451 .producer_thread = producer,
462 .producer_thread = producer,
473 .producer_thread = producer,
|
| /linux/kernel/trace/ |
| H A D | ring_buffer_benchmark.c | 33 static struct task_struct *producer; variable
39 MODULE_PARM_DESC(disable_reader, "only run producer");
52 MODULE_PARM_DESC(producer_nice, "nice prio for producer");
58 MODULE_PARM_DESC(producer_fifo, "use fifo for producer: 0 - disabled, 1 - low prio, 2 - fifo");
191 * Continue running until the producer specifically asks to stop in ring_buffer_consumer()
218 /* Wait till the producer wakes us up when there is more data in ring_buffer_consumer()
219 * available or when the producer wants us to finish reading. in ring_buffer_consumer()
316 trace_printk("Running Producer at SCHED_FIFO %s\n", in ring_buffer_producer()
319 trace_printk("Running Producer at nice: %d\n", in ring_buffer_producer()
449 producer = kthread_run(ring_buffer_producer_thread, in ring_buffer_benchmark_init()
[all …]
|
| /linux/Documentation/devicetree/bindings/net/ |
| H A D | mdio-mux-multiplexer.yaml | 14 of a mux producer device. The mux producer can be of any type like mmio mux
15 producer, gpio mux producer or generic register based mux producer.
36 mux: mux-controller { // Mux Producer
|
| /linux/drivers/net/ethernet/qlogic/qlcnic/ |
| H A D | qlcnic_io.c | 277 u32 producer; in qlcnic_82xx_change_filter() local
280 producer = tx_ring->producer; in qlcnic_82xx_change_filter()
281 hwdesc = &tx_ring->desc_head[tx_ring->producer]; in qlcnic_82xx_change_filter()
297 tx_ring->producer = get_next_index(producer, tx_ring->num_desc); in qlcnic_82xx_change_filter()
377 u32 producer = tx_ring->producer; in qlcnic_tx_encap_pkt() local
407 hwdesc = &tx_ring->desc_head[producer]; in qlcnic_tx_encap_pkt()
408 tx_ring->cmd_buf_arr[producer].skb = NULL; in qlcnic_tx_encap_pkt()
413 producer = get_next_index(producer, tx_ring->num_desc); in qlcnic_tx_encap_pkt()
416 tx_ring->producer = producer; in qlcnic_tx_encap_pkt()
418 /* Make sure updated tx_ring->producer is visible in qlcnic_tx_encap_pkt()
[all …]
|
| /linux/tools/testing/selftests/sync/ |
| H A D | sync_stress_consumer.c | 2 * sync stress test: producer/consumer
90 * Every producer increments the counter, the consumer in mpsc_producer_thread()
98 "Error advancing producer timeline\n"); in mpsc_producer_thread()
129 * Make sure we see an increment from every producer thread. in mpcs_consumer_thread()
143 /* Release the producer threads */ in mpcs_consumer_thread()
145 "Failure releasing producer threads\n"); in mpcs_consumer_thread()
|
| /linux/kernel/bpf/ |
| H A D | ringbuf.c | 21 /* consumer page and producer page */
34 /* For user-space producer ring buffers, an atomic_t busy bit is used
36 * the spinlock that is used for kernel-producer ring buffers. This is
50 /* Consumer and producer counters are put into separate pages to
56 * page as the producer, so that it shares the same cache line.
58 * Kernel-producer
60 * The producer position and data pages are mapped as r/o in
65 * User-space producer
160 * take into account few extra pages for consumer/producer pages and
287 * and allow writable mappings to both the producer in ringbuf_map_mmap_user()
[all …]
|
| /linux/drivers/md/dm-vdo/ |
| H A D | funnel-queue.h | 14 * (multi-producer) and delivers them to a single thread (single-consumer). "Funnel" is an attempt
15 * to evoke the image of requests from more than one producer being "funneled down" to a single
36 * at which a preempted producer will prevent the consumers from seeing items added to the queue by
53 * producer and consumer fields in the structure will land on separate cache lines. This should be
91 * other producer threads can see the entry (the xchg) and try to update the "next" field. in vdo_funnel_queue_put()
|
| /linux/include/uapi/linux/ |
| H A D | smc_diag.h | 69 struct smc_diag_cursor rx_prod; /* received producer cursor */
72 struct smc_diag_cursor tx_prod; /* sent producer cursor */
74 __u8 rx_prod_flags; /* received producer flags */
76 __u8 tx_prod_flags; /* sent producer flags */
|
| /linux/drivers/net/wireless/ath/ath11k/ |
| H A D | hal_desc.h | 34 * Producer: SW/FW
509 * Producer: RXDMA
710 * Producer: RXDMA
765 * Indicates the number of times the producer of entries into
807 * Producer: RXDMA
859 * Indicates the number of times the producer of entries into
900 * Producer: SW
1154 * producer of entries into the Ring has looped around the
1163 * use this field to figure out up to where the producer of
1378 * producer of entries into the Ring has looped around the
[all …]
|
| /linux/tools/testing/selftests/bpf/ |
| H A D | xsk.h | 33 __u32 *producer; \
111 r->cached_prod = __atomic_load_n(r->producer, __ATOMIC_ACQUIRE); in xsk_cons_nb_avail()
132 * this to the kernel by writing the producer pointer. in xsk_ring_prod__submit()
134 __atomic_store_n(prod->producer, *prod->producer + nb, __ATOMIC_RELEASE); in xsk_ring_prod__submit()
|
| H A D | xsk.c | 195 fill->producer = map + off.fr.producer; in xsk_create_umem_rings()
211 comp->producer = map + off.cr.producer; in xsk_create_umem_rings()
636 rx->producer = rx_map + off.rx.producer; in xsk_socket__create_shared()
640 rx->cached_prod = *rx->producer; in xsk_socket__create_shared()
657 tx->producer = tx_map + off.tx.producer; in xsk_socket__create_shared()
661 tx->cached_prod = *tx->producer; in xsk_socket__create_shared()
|
| /linux/Documentation/networking/ |
| H A D | af_xdp.rst | 64 single-consumer / single-producer (for performance reasons), the new
121 The UMEM has two single-producer/single-consumer rings that are used
129 TX. All rings are single-producer/single-consumer, so the user-space
138 The rings are head(producer)/tail(consumer) based rings. A producer
140 producer member, and increasing the producer index. A consumer reads
306 rings, and they are single producer, single consumer rings, you need
352 space is a producer. When this option is set in the bind call, the
401 be used. Note, that the rings are single-producer single-consumer, so
584 // __u32 *producer;
590 // __u32 *producer;
[all …]
|
| /linux/include/acpi/ |
| H A D | acrestyp.h | 112 /* Producer/Consumer */
358 u8 producer_consumer; /* For values, see Producer/Consumer above */
398 …u8 producer_consumer; /* For values, see Producer/Consumer …
537 u8 producer_consumer; /* For values, see Producer/Consumer above */
576 u8 producer_consumer; /* For values, see Producer/Consumer above */
586 u8 producer_consumer; /* For values, see Producer/Consumer above */
597 u8 producer_consumer; /* For values, see Producer/Consumer above */
|
| /linux/drivers/net/ethernet/qlogic/netxen/ |
| H A D | netxen_nic_init.c | 1811 int producer, count = 0; in netxen_post_rx_buffers() local
1815 producer = rds_ring->producer; in netxen_post_rx_buffers()
1831 pdesc = &rds_ring->desc_head[producer]; in netxen_post_rx_buffers()
1836 producer = get_next_index(producer, rds_ring->num_desc); in netxen_post_rx_buffers()
1840 rds_ring->producer = producer; in netxen_post_rx_buffers()
1842 (producer-1) & (rds_ring->num_desc-1)); in netxen_post_rx_buffers()
1847 * receive ring producer in netxen_post_rx_buffers()
1853 ((producer - 1) & in netxen_post_rx_buffers()
1869 int producer, count = 0; in netxen_post_rx_buffers_nodb() local
1875 producer = rds_ring->producer; in netxen_post_rx_buffers_nodb()
[all …]
|
| H A D | netxen_nic_main.c | 105 NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer); in netxen_nic_update_cmd_producer()
1239 tx_ring->producer = 0; in netxen_nic_attach()
1848 u32 producer; in netxen_tso_check() local
1915 producer = tx_ring->producer; in netxen_tso_check()
1922 hwdesc = &tx_ring->desc_head[producer]; in netxen_tso_check()
1923 tx_ring->cmd_buf_arr[producer].skb = NULL; in netxen_tso_check()
1938 producer = get_next_index(producer, tx_ring->num_desc); in netxen_tso_check()
1946 hwdesc = &tx_ring->desc_head[producer]; in netxen_tso_check()
1947 tx_ring->cmd_buf_arr[producer].skb = NULL; in netxen_tso_check()
1955 producer = get_next_index(producer, tx_ring->num_desc); in netxen_tso_check()
[all …]
|
| /linux/Documentation/PCI/ |
| H A D | acpi-info.rst | 55 ACPI defines a Consumer/Producer bit to distinguish the bridge registers
56 ("Consumer") from the bridge apertures ("Producer") [4, 5], but early
58 spec defines Consumer/Producer only for the Extended Address Space
64 Consumer/Producer meant there was no way to describe bridge registers in
141 General Flags: Bit [0] Consumer/Producer:
|
| /linux/Documentation/bpf/ |
| H A D | ringbuf.rst | 128 of consumer/producer, respectively.
162 - producer counter denotes amount of data reserved by all producers.
164 Each time a record is reserved, producer that "owns" the record will
165 successfully advance producer counter. At that point, data is still not yet
178 Producer counter increments are serialized under spinlock, so there is
|