Netdev Archive on lore.kernel.org
 help / Atom feed
From: Vlad Buslov <vladbu@mellanox.com>
To: netdev@vger.kernel.org
Cc: jhs@mojatatu.com, xiyou.wangcong@gmail.com, jiri@resnulli.us,
	davem@davemloft.net, sbrivio@redhat.com,
	Vlad Buslov <vladbu@mellanox.com>
Subject: [PATCH net-next v3 00/12] Refactor flower classifier to remove dependency on rtnl lock
Date: Thu, 21 Mar 2019 15:17:32 +0200
Message-ID: <20190321131744.19224-1-vladbu@mellanox.com> (raw)

Currently, all netlink protocol handlers for updating rules, actions and
qdiscs are protected with single global rtnl lock which removes any
possibility for parallelism. This patch set is a third step to remove
rtnl lock dependency from TC rules update path.

Recently, new rtnl registration flag RTNL_FLAG_DOIT_UNLOCKED was added.
TC rule update handlers (RTM_NEWTFILTER, RTM_DELTFILTER, etc.) are
already registered with this flag and only take rtnl lock when qdisc or
classifier requires it. Classifiers can indicate that their ops
callbacks don't require caller to hold rtnl lock by setting the
TCF_PROTO_OPS_DOIT_UNLOCKED flag. The goal of this change is to refactor
flower classifier to support unlocked execution and register it with
unlocked flag.

This patch set implements following changes to make flower classifier
concurrency-safe:

- Implement reference counting for individual filters. Change fl_get to
  take reference to filter. Implement tp->ops->put callback that was
  introduced in cls API patch set to release reference to flower filter.

- Use tp->lock spinlock to protect internal classifier data structures
  from concurrent modification.

- Handle concurrent tcf proto deletion by returning EAGAIN, which will
  cause cls API to retry and create new proto instance or return error
  to the user (depending on message type).

- Handle concurrent insertion of filter with same priority and handle by
  returning EAGAIN, which will cause cls API to lookup filter again and
  process it accordingly to netlink message flags.

- Extend flower mask with reference counting and protect masks list with
  masks_lock spinlock.

- Prevent concurrent mask insertion by inserting temporary value to
  masks hash table. This is necessary because mask initialization is a
  sleeping operation and cannot be done while holding tp->lock.

Both chain level and classifier level conflicts are resolved by
returning -EAGAIN to cls API that results restart of whole operation.
This retry mechanism is a result of fine-grained locking approach used
in this and previous changes in series and is necessary to allow
concurrent updates on same chain instance. Alternative approach would be
to lock the whole chain while updating filters on any of child tp's,
adding and removing classifier instances from the chain. However, since
most CPU-intensive parts of filter update code are specifically in
classifier code and its dependencies (extensions and hw offloads), such
approach would negate most of the gains introduced by this change and
previous changes in the series when updating same chain instance.

Tcf hw offloads API is not changed by this patch set and still requires
caller to hold rtnl lock. Refactored flower classifier tracks rtnl lock
state by means of 'rtnl_held' flag provided by cls API and obtains the
lock before calling hw offloads. Following patch set will lift this
restriction and refactor cls hw offloads API to support unlocked
execution.

With these changes flower classifier is safely registered with
TCF_PROTO_OPS_DOIT_UNLOCKED flag in last patch.

Changes from V2 to V3:
- Rebase on latest net-next

Changes from V1 to V2:
- Extend cover letter with explanation about retry mechanism.
- Rebase on current net-next.
- Patch 1:
  - Use rcu_dereference_raw() for tp->root dereference.
  - Update comment in fl_head_dereference().
- Patch 2:
  - Remove redundant check in fl_change error handling code.
  - Add empty line between error check and new handle assignment.
- Patch 3:
  - Refactor loop in fl_get_next_filter() to improve readability.
- Patch 4:
  - Refactor __fl_delete() to improve readability.
- Patch 6:
  - Fix comment in fl_check_assign_mask().
- Patch 9:
  - Extend commit message.
  - Fix error code in comment.
- Patch 11:
  - Fix fl_hw_replace_filter() to always release rtnl lock in error
    handlers.
- Patch 12:
  - Don't take rtnl lock before calling __fl_destroy_filter() in
    workqueue context.
  - Extend commit message with explanation why flower still takes rtnl
    lock before calling hardware offloads API.

Github: <https://github.com/vbuslov/linux/tree/unlocked-flower-cong3>

Vlad Buslov (12):
  net: sched: flower: don't check for rtnl on head dereference
  net: sched: flower: refactor fl_change
  net: sched: flower: introduce reference counting for filters
  net: sched: flower: track filter deletion with flag
  net: sched: flower: add reference counter to flower mask
  net: sched: flower: handle concurrent mask insertion
  net: sched: flower: protect masks list with spinlock
  net: sched: flower: handle concurrent filter insertion in fl_change
  net: sched: flower: handle concurrent tcf proto deletion
  net: sched: flower: protect flower classifier state with spinlock
  net: sched: flower: track rtnl lock state
  net: sched: flower: set unlocked flag for flower proto ops

 net/sched/cls_flower.c | 433 +++++++++++++++++++++++++++++++----------
 1 file changed, 325 insertions(+), 108 deletions(-)

-- 
2.21.0


             reply index

Thread overview: 22+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2019-03-21 13:17 Vlad Buslov [this message]
2019-03-21 13:17 ` [PATCH net-next v3 01/12] net: sched: flower: don't check for rtnl on head dereference Vlad Buslov
2019-03-21 13:51   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 02/12] net: sched: flower: refactor fl_change Vlad Buslov
2019-03-21 13:53   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 03/12] net: sched: flower: introduce reference counting for filters Vlad Buslov
2019-03-21 14:00   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 04/12] net: sched: flower: track filter deletion with flag Vlad Buslov
2019-03-21 14:04   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 05/12] net: sched: flower: add reference counter to flower mask Vlad Buslov
2019-03-21 13:17 ` [PATCH net-next v3 06/12] net: sched: flower: handle concurrent mask insertion Vlad Buslov
2019-03-21 13:17 ` [PATCH net-next v3 07/12] net: sched: flower: protect masks list with spinlock Vlad Buslov
2019-03-21 13:17 ` [PATCH net-next v3 08/12] net: sched: flower: handle concurrent filter insertion in fl_change Vlad Buslov
2019-03-21 13:17 ` [PATCH net-next v3 09/12] net: sched: flower: handle concurrent tcf proto deletion Vlad Buslov
2019-03-21 14:06   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 10/12] net: sched: flower: protect flower classifier state with spinlock Vlad Buslov
2019-03-21 14:09   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 11/12] net: sched: flower: track rtnl lock state Vlad Buslov
2019-03-21 14:11   ` Jiri Pirko
2019-03-21 13:17 ` [PATCH net-next v3 12/12] net: sched: flower: set unlocked flag for flower proto ops Vlad Buslov
2019-03-21 14:13   ` Jiri Pirko
2019-03-21 21:33 ` [PATCH net-next v3 00/12] Refactor flower classifier to remove dependency on rtnl lock David Miller

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20190321131744.19224-1-vladbu@mellanox.com \
    --to=vladbu@mellanox.com \
    --cc=davem@davemloft.net \
    --cc=jhs@mojatatu.com \
    --cc=jiri@resnulli.us \
    --cc=netdev@vger.kernel.org \
    --cc=sbrivio@redhat.com \
    --cc=xiyou.wangcong@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

Netdev Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/netdev/0 netdev/git/0.git
	git clone --mirror https://lore.kernel.org/netdev/1 netdev/git/1.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 netdev netdev/ https://lore.kernel.org/netdev \
		netdev@vger.kernel.org netdev@archiver.kernel.org
	public-inbox-index netdev


Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.netdev


AGPL code for this site: git clone https://public-inbox.org/ public-inbox