s390/qeth: fixes 2020-03-11
Subsystems (4)
cover s390/qeth: fixes 2020-03-11
Hi Dave,
please apply the following patch series for qeth to netdev's net tree.
Just one fix to get the RX buffer pool resizing right, with two preparatory cleanups.
This is on the larger side given where we are in the -rc cycle, but a big chunk of the delta is just refactoring to make the fix look nice.
I intentionally split these off from yesterday's series. No objections if you'd rather punt them to net-next, the series should apply cleanly.
Thanks,
Julian
Julian Wiedmann (3):
s390/qeth: use page pointers to manage RX buffer pool s390/qeth: refactor buffer pool code
s390/qeth: implement smarter resizing of the RX buffer pool
drivers/s390/net/qeth_core.h | 4 +- drivers/s390/net/qeth_core_main.c | 161 ++++++++++++++++++++---------- drivers/s390/net/qeth_core_sys.c | 9 +- drivers/s390/net/qeth_l3_sys.c | 9 +- 4 files changed, 119 insertions(+), 64 deletions(-)
Signature · 1 line
2.17.1
PATCH 1/3 s390/qeth: use page pointers to manage RX buffer pool
The RX buffer elements are always backed with full pages, reflect this in the pointer type.
--- drivers/s390/net/qeth_core.h | 2 +- drivers/s390/net/qeth_core_main.c | 35 +++++++++++++++---------------- 2 files changed, 18 insertions(+), 19 deletions(-)
drivers/s390/net/qeth_core.h +1 -1
@@ -369,7 +369,7 @@ enum qeth_qdio_info_states {struct qeth_buffer_pool_entry {struct list_head list;struct list_head init_list; -void *elements[QDIO_MAX_ELEMENTS_PER_BUFFER ]; +struct page *elements[QDIO_MAX_ELEMENTS_PER_BUFFER ]; };struct qeth_qdio_buffer_pool {
drivers/s390/net/qeth_core_main.c +17 -18
@@ -215,7 +215,6 @@ EXPORT_SYMBOL_GPL(qeth_clear_working_pool_list);static int qeth_alloc_buffer_pool (struct qeth_card *card) {struct qeth_buffer_pool_entry *pool_entry; -void *ptr;int i, j;QETH_CARD_TEXT (card,5 ,"alocpool" );
@@ -225,17 +224,18 @@ static int qeth_alloc_buffer_pool(struct qeth_card *card)qeth_free_buffer_pool (card);return -ENOMEM ; } +for (j =0 ; j <QETH_MAX_BUFFER_ELEMENTS (card); ++j) { - ptr = (void *)__get_free_page (GFP_KERNEL ); -if (!ptr) { +struct page *page =alloc_page (GFP_KERNEL ); + +if (!page) {while (j >0 ) -free_page ((unsigned long ) - pool_entry->elements[--j]); +__free_page (pool_entry->elements[--j]);kfree (pool_entry);qeth_free_buffer_pool (card);return -ENOMEM ; } - pool_entry->elements[j] = ptr; + pool_entry->elements[j] = page; }list_add (&pool_entry->init_list, &card->qdio.init_pool.entry_list);
@@ -1177,7 +1177,7 @@ static void qeth_free_buffer_pool(struct qeth_card *card)list_for_each_entry_safe (pool_entry, tmp, &card->qdio.init_pool.entry_list, init_list){for (i =0 ; i <QETH_MAX_BUFFER_ELEMENTS (card); ++i) -free_page ((unsigned long )pool_entry->elements[i]); +__free_page (pool_entry->elements[i]);list_del (&pool_entry->init_list);kfree (pool_entry); }
@@ -2573,7 +2573,6 @@ static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry(struct list_head *plh;struct qeth_buffer_pool_entry *entry;int i, free; -struct page *page;if (list_empty (&card->qdio.in_buf_pool.entry_list))return NULL ;
@@ -2582,7 +2581,7 @@ static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( entry = list_entry(plh, struct qeth_buffer_pool_entry, list); free =1 ;for (i =0 ; i <QETH_MAX_BUFFER_ELEMENTS (card); ++i) { -if (page_count (virt_to_page (entry->elements[i])) >1 ) { +if (page_count (entry->elements[i]) >1 ) { free =0 ;break ; }
@@ -2597,15 +2596,15 @@ static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( entry =list_entry (card->qdio.in_buf_pool.entry_list.next, struct qeth_buffer_pool_entry, list);for (i =0 ; i <QETH_MAX_BUFFER_ELEMENTS (card); ++i) { -if (page_count (virt_to_page (entry->elements[i])) >1 ) { - page =alloc_page (GFP_ATOMIC ); -if (!page) { +if (page_count (entry->elements[i]) >1 ) { +struct page *page =alloc_page (GFP_ATOMIC ); + +if (!page)return NULL ; - }else { -free_page ((unsigned long )entry->elements[i]); - entry->elements[i] =page_address (page); -QETH_CARD_STAT_INC (card, rx_sg_alloc_page); - } + +__free_page (entry->elements[i]); + entry->elements[i] = page; +QETH_CARD_STAT_INC (card, rx_sg_alloc_page); } }list_del_init (&entry->list);
@@ -2641,7 +2640,7 @@ static int qeth_init_input_buffer(struct qeth_card *card,for (i =0 ; i <QETH_MAX_BUFFER_ELEMENTS (card); ++i) { buf->buffer->element[i].length =PAGE_SIZE ; buf->buffer->element[i].addr = -virt_to_phys (pool_entry->elements[i]); +page_to_phys (pool_entry->elements[i]);if (i ==QETH_MAX_BUFFER_ELEMENTS (card) -1 ) buf->buffer->element[i].eflags =SBAL_EFLAGS_LAST_ENTRY ;else
Signature · 1 line
2.17.1
PATCH 2/3 s390/qeth: refactor buffer pool code
In reply to Julian WiedmannIn preparation for a subsequent fix, split out helpers to allocate/free individual pool entries.
--- drivers/s390/net/qeth_core_main.c | 83 +++++++++++++++++++------------ 1 file changed, 51 insertions(+), 32 deletions(-)
drivers/s390/net/qeth_core_main.c +51 -32
@@ -65,7 +65,6 @@ static struct lock_class_key qdio_out_skb_queue_key;static void qeth_issue_next_read_cb (struct qeth_card *card,struct qeth_cmd_buffer *iob,unsigned int data_length); -static void qeth_free_buffer_pool (struct qeth_card *);static int qeth_qdio_establish (struct qeth_card *);static void qeth_free_qdio_queues (struct qeth_card *card); static void qeth_notify_skbs(struct qeth_qdio_out_q *queue,
@@ -212,33 +211,66 @@ void qeth_clear_working_pool_list(struct qeth_card *card) }EXPORT_SYMBOL_GPL (qeth_clear_working_pool_list); +static void qeth_free_pool_entry (struct qeth_buffer_pool_entry *entry) +{ +unsigned int i; + +for (i =0 ; i <ARRAY_SIZE (entry->elements); i++) { +if (entry->elements[i]) +__free_page (entry->elements[i]); + } + +kfree (entry); +} + +static void qeth_free_buffer_pool (struct qeth_card *card) +{ +struct qeth_buffer_pool_entry *entry, *tmp; + +list_for_each_entry_safe (entry, tmp, &card->qdio.init_pool.entry_list, + init_list) { +list_del (&entry->init_list); +qeth_free_pool_entry (entry); + } +} + +static struct qeth_buffer_pool_entry *qeth_alloc_pool_entry (unsigned int pages) +{ +struct qeth_buffer_pool_entry *entry; +unsigned int i; + + entry =kzalloc (sizeof (*entry),GFP_KERNEL ); +if (!entry) +return NULL ; + +for (i =0 ; i < pages; i++) { + entry->elements[i] =alloc_page (GFP_KERNEL ); + +if (!entry->elements[i]) { +qeth_free_pool_entry (entry); +return NULL ; + } + } + +return entry; +} +static int qeth_alloc_buffer_pool (struct qeth_card *card) { -struct qeth_buffer_pool_entry *pool_entry; -int i, j; +unsigned int buf_elements =QETH_MAX_BUFFER_ELEMENTS (card); +unsigned int i;QETH_CARD_TEXT (card,5 ,"alocpool" );for (i =0 ; i < card->qdio.init_pool.buf_count; ++i) { - pool_entry =kzalloc (sizeof (*pool_entry),GFP_KERNEL ); -if (!pool_entry) { +struct qeth_buffer_pool_entry *entry; + + entry =qeth_alloc_pool_entry (buf_elements); +if (!entry) {qeth_free_buffer_pool (card);return -ENOMEM ; } -for (j =0 ; j <QETH_MAX_BUFFER_ELEMENTS (card); ++j) { -struct page *page =alloc_page (GFP_KERNEL ); - -if (!page) { -while (j >0 ) -__free_page (pool_entry->elements[--j]); -kfree (pool_entry); -qeth_free_buffer_pool (card); -return -ENOMEM ; - } - pool_entry->elements[j] = page; - } -list_add (&pool_entry->init_list, - &card->qdio.init_pool.entry_list); +list_add (&entry->init_list, &card->qdio.init_pool.entry_list); }return 0 ; }
@@ -1170,19 +1202,6 @@ void qeth_drain_output_queues(struct qeth_card *card) }EXPORT_SYMBOL_GPL (qeth_drain_output_queues); -static void qeth_free_buffer_pool (struct qeth_card *card) -{ -struct qeth_buffer_pool_entry *pool_entry, *tmp; -int i =0 ; -list_for_each_entry_safe (pool_entry, tmp, - &card->qdio.init_pool.entry_list, init_list){ -for (i =0 ; i <QETH_MAX_BUFFER_ELEMENTS (card); ++i) -__free_page (pool_entry->elements[i]); -list_del (&pool_entry->init_list); -kfree (pool_entry); - } -} -static int qeth_osa_set_output_queues (struct qeth_card *card,bool single) {unsigned int count = single ?1 : card->dev->num_tx_queues;
Signature · 1 line
2.17.1
PATCH 3/3 s390/qeth: implement smarter resizing of the RX buffer pool
In reply to Julian WiedmannThe RX buffer pool is allocated in qeth_alloc_qdio_queues(). A subsequent pool resizing is then handled in a very simple way:
first free the current pool, then allocate a new pool of the requested size.
There's two ways where this can go wrong:
1. if the resize action happens _before_ the initial pool was allocated, then a subsequent initialization will call qeth_alloc_qdio_queues() and fill the pool with a second(!) set of pages. We consume twice the planned amount of memory.
This is easy to fix - just skip the resizing if the queues haven't been allocated yet.
2. if the initial pool was created by qeth_alloc_qdio_queues() but a subsequent resizing fails, then the device has no(!) RX buffer pool. The next initialization will _not_ call qeth_alloc_qdio_queues(), and attempting to back the RX buffers with pages in qeth_init_qdio_queues() will fail.
Not very difficult to fix either - instead of re-allocating the whole pool, just allocate/free as many entries to match the desired size.
--- drivers/s390/net/qeth_core.h | 2 +- drivers/s390/net/qeth_core_main.c | 55 ++++++++++++++++++++++++++----- drivers/s390/net/qeth_core_sys.c | 9 +++-- drivers/s390/net/qeth_l3_sys.c | 9 +++-- 4 files changed, 56 insertions(+), 19 deletions(-)
drivers/s390/net/qeth_core.h +1 -1
@@ -983,7 +983,7 @@ extern const struct attribute_group qeth_device_blkt_group;extern const struct device_type qeth_generic_devtype;const char *qeth_get_cardname_short (struct qeth_card *); -int qeth_realloc_buffer_pool (struct qeth_card *,int ); +int qeth_resize_buffer_pool (struct qeth_card *card,unsigned int count);int qeth_core_load_discipline (struct qeth_card *,enum qeth_discipline_id );void qeth_core_free_discipline (struct qeth_card *);
drivers/s390/net/qeth_core_main.c +47 -8
65 lines not on this page · raw message
drivers/s390/net/qeth_core_sys.c +4 -5
@@ -247,8 +247,8 @@ static ssize_t qeth_dev_bufcnt_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct qeth_card *card = dev_get_drvdata(dev); +unsigned int cnt;char *tmp; -int cnt, old_cnt;int rc =0 ;mutex_lock (&card->conf_mutex);
@@ -257,13 +257,12 @@ static ssize_t qeth_dev_bufcnt_store(struct device *dev, goto out; } - old_cnt = card->qdio.in_buf_pool.buf_count; cnt =simple_strtoul (buf, &tmp,10 ); cnt = (cnt <QETH_IN_BUF_COUNT_MIN ) ?QETH_IN_BUF_COUNT_MIN : ((cnt >QETH_IN_BUF_COUNT_MAX ) ?QETH_IN_BUF_COUNT_MAX : cnt); -if (old_cnt != cnt) { - rc =qeth_realloc_buffer_pool (card, cnt); - } + + rc =qeth_resize_buffer_pool (card, cnt); + out:mutex_unlock (&card->conf_mutex);return rc ? rc : count;
drivers/s390/net/qeth_l3_sys.c +4 -5
@@ -206,12 +206,11 @@ static ssize_t qeth_l3_dev_sniffer_store(struct device *dev,qdio_get_ssqd_desc (CARD_DDEV (card), &card->ssqd);if (card->ssqd.qdioac2 &CHSC_AC2_SNIFFER_AVAILABLE ) { card->options.sniffer = i; -if (card->qdio.init_pool.buf_count != -QETH_IN_BUF_COUNT_MAX ) -qeth_realloc_buffer_pool (card, -QETH_IN_BUF_COUNT_MAX ); - }else +qeth_resize_buffer_pool (card,QETH_IN_BUF_COUNT_MAX ); + }else { rc = -EPERM ; + } +break ;default : rc = -EINVAL ;
Signature · 1 line
2.17.1
David Miller
maintainerFrom: Julian Wiedmann <[email protected]>
Date: Wed, 11 Mar 2020 18:07:08 +0100
Quoted 9 lines
please apply the following patch series for qeth to netdev's net tree.
Just one fix to get the RX buffer pool resizing right, with two preparatory cleanups.
This is on the larger side given where we are in the -rc cycle, but a big chunk of the delta is just refactoring to make the fix look nice.I intentionally split these off from yesterday's series. No objections if you'd rather punt them to net-next, the series should apply cleanly.
Series applied, thanks.