| Message ID | 20201126122426.25243-2-tparkin@katalix.com (mailing list archive) |
|---|---|
| State | Changes Requested |
| Delegated to: | Netdev Maintainers |
| Headers | show |
| Series | add ppp_generic ioctl(s) to bridge channels | expand |
| Context | Check | Description |
|---|---|---|
| netdev/cover_letter | success | Link |
| netdev/fixes_present | success | Link |
| netdev/patch_count | success | Link |
| netdev/tree_selection | success | Clearly marked for net-next |
| netdev/subject_prefix | success | Link |
| netdev/source_inline | success | Was 0 now: 0 |
| netdev/verify_signedoff | success | Link |
| netdev/module_param | success | Was 0 now: 0 |
| netdev/build_32bit | fail | Errors and warnings before: 22 this patch: 29 |
| netdev/kdoc | success | Errors and warnings before: 0 this patch: 0 |
| netdev/verify_fixes | success | Link |
| netdev/checkpatch | warning | WARNING: line length of 83 exceeds 80 columns WARNING: line length of 86 exceeds 80 columns WARNING: line length of 88 exceeds 80 columns |
| netdev/build_allmodconfig_warn | fail | Errors and warnings before: 24 this patch: 31 |
| netdev/header_inline | success | Link |
| netdev/stable | success | Stable not CCed |
Hi Tom,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on net-next/master]
url: https://github.com/0day-ci/linux/commits/Tom-Parkin/add-ppp_generic-ioctl-s-to-bridge-channels/20201126-202933
base: https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git 594e31bcebd6b8127ab8bcf37068ecef6c996459
config: alpha-randconfig-s032-20201126 (attached as .config)
compiler: alpha-linux-gcc (GCC) 9.3.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# apt-get install sparse
# sparse version: v0.6.3-151-g540c2c4b-dirty
# https://github.com/0day-ci/linux/commit/d956f9918541d0b973ce241bd26020c3d08878db
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Tom-Parkin/add-ppp_generic-ioctl-s-to-bridge-channels/20201126-202933
git checkout d956f9918541d0b973ce241bd26020c3d08878db
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=alpha
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
"sparse warnings: (new ones prefixed by >>)"
>> drivers/net/ppp/ppp_generic.c:641:9: sparse: sparse: incompatible types in comparison expression (different address spaces):
>> drivers/net/ppp/ppp_generic.c:641:9: sparse: struct channel [noderef] __rcu *
>> drivers/net/ppp/ppp_generic.c:641:9: sparse: struct channel *
drivers/net/ppp/ppp_generic.c:644:9: sparse: sparse: incompatible types in comparison expression (different address spaces):
drivers/net/ppp/ppp_generic.c:644:9: sparse: struct channel [noderef] __rcu *
drivers/net/ppp/ppp_generic.c:644:9: sparse: struct channel *
drivers/net/ppp/ppp_generic.c:666:16: sparse: sparse: incompatible types in comparison expression (different address spaces):
drivers/net/ppp/ppp_generic.c:666:16: sparse: struct channel [noderef] __rcu *
drivers/net/ppp/ppp_generic.c:666:16: sparse: struct channel *
drivers/net/ppp/ppp_generic.c:672:20: sparse: sparse: incompatible types in comparison expression (different address spaces):
drivers/net/ppp/ppp_generic.c:672:20: sparse: struct channel [noderef] __rcu *
drivers/net/ppp/ppp_generic.c:672:20: sparse: struct channel *
drivers/net/ppp/ppp_generic.c:680:9: sparse: sparse: incompatible types in comparison expression (different address spaces):
drivers/net/ppp/ppp_generic.c:680:9: sparse: struct channel [noderef] __rcu *
drivers/net/ppp/ppp_generic.c:680:9: sparse: struct channel *
drivers/net/ppp/ppp_generic.c:681:9: sparse: sparse: incompatible types in comparison expression (different address spaces):
drivers/net/ppp/ppp_generic.c:681:9: sparse: struct channel [noderef] __rcu *
drivers/net/ppp/ppp_generic.c:681:9: sparse: struct channel *
drivers/net/ppp/ppp_generic.c:2209:16: sparse: sparse: incompatible types in comparison expression (different address spaces):
drivers/net/ppp/ppp_generic.c:2209:16: sparse: struct channel [noderef] __rcu *
drivers/net/ppp/ppp_generic.c:2209:16: sparse: struct channel *
vim +641 drivers/net/ppp/ppp_generic.c
609
610 /* Bridge one PPP channel to another.
611 * When two channels are bridged, ppp_input on one channel is redirected to
612 * the other's ops->start_xmit handler.
613 * In order to safely bridge channels we must reject channels which are already
614 * part of a bridge instance, or which form part of an existing unit.
615 * Once successfully bridged, each channel holds a reference on the other
616 * to prevent it being freed while the bridge is extant.
617 */
618 static int ppp_bridge_channels(struct channel *pch, struct channel *pchb)
619 {
620 int ret = -EALREADY;
621
622 /* We need to take each channel upl for access to the 'ppp' field,
623 * and each channel downl for write access to the 'bridge' field.
624 */
625
626 read_lock_bh(&pch->upl);
627 if (pch->ppp)
628 goto out0;
629
630 spin_lock(&pch->downl);
631
632 read_lock_bh(&pchb->upl);
633 if (pchb->ppp)
634 goto out1;
635
636 spin_lock(&pchb->downl);
637
638 if (pch->bridge || pchb->bridge)
639 goto out2;
640
> 641 rcu_assign_pointer(pch->bridge, pchb);
642 refcount_inc(&pchb->file.refcnt);
643
644 rcu_assign_pointer(pchb->bridge, pch);
645 refcount_inc(&pch->file.refcnt);
646
647 ret = 0;
648
649 out2:
650 spin_unlock(&pchb->downl);
651 out1:
652 read_unlock_bh(&pchb->upl);
653 spin_unlock(&pch->downl);
654 out0:
655 read_unlock_bh(&pch->upl);
656
657 return ret;
658 }
659
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
On Thu, Nov 26, 2020 at 12:24:25PM +0000, Tom Parkin wrote: > This new ioctl pair allows two ppp channels to be bridged together: > frames arriving in one channel are transmitted in the other channel > and vice versa. Thanks! Some comments below (mostly about locking). > The practical use for this is primarily to support the L2TP Access > Concentrator use-case. The end-user session is presented as a ppp > channel (typically PPPoE, although it could be e.g. PPPoA, or even PPP > over a serial link) and is switched into a PPPoL2TP session for > transmission to the LNS. At the LNS the PPP session is terminated in > the ISP's network. > > When a PPP channel is bridged to another it takes a reference on the > other's struct ppp_file. This reference is dropped when the channels > are unbridged, which can occur either explicitly on userspace calling > the PPPIOCUNBRIDGECHAN ioctl, or implicitly when either channel in the > bridge is unregistered. > > In order to implement the channel bridge, struct channel is extended > with a new field, 'bridge', which points to the other struct channel > making up the bridge. > > This pointer is RCU protected to avoid adding another lock to the data > path. > > To guard against concurrent writes to the pointer, the existing struct > channel lock 'downl' use is extended (rather than adding a new lock). > Order of lock acquisition is maintained: i.e. the channel 'upl' lock is > always acquired before 'downl' in code paths that need to hold both. > > Signed-off-by: Tom Parkin <tparkin@katalix.com> > --- > drivers/net/ppp/ppp_generic.c | 147 ++++++++++++++++++++++++++++++++- > include/uapi/linux/ppp-ioctl.h | 2 + > 2 files changed, 147 insertions(+), 2 deletions(-) > > diff --git a/drivers/net/ppp/ppp_generic.c b/drivers/net/ppp/ppp_generic.c > index 7d005896a0f9..5e563bfb8e2a 100644 > --- a/drivers/net/ppp/ppp_generic.c > +++ b/drivers/net/ppp/ppp_generic.c > @@ -170,11 +170,12 @@ struct channel { > struct list_head list; /* link in all/new_channels list */ > struct ppp_channel *chan; /* public channel data structure */ > struct rw_semaphore chan_sem; /* protects `chan' during chan ioctl */ > - spinlock_t downl; /* protects `chan', file.xq dequeue */ > + spinlock_t downl; /* protects `chan', 'bridge', file.xq dequeue */ > struct ppp *ppp; /* ppp unit we're connected to */ > struct net *chan_net; /* the net channel belongs to */ > struct list_head clist; /* link in list of channels per unit */ > rwlock_t upl; /* protects `ppp' */ > + struct channel *bridge; /* "bridged" ppp channel */ Missing __rcu annotation (as reported by kernel test robot): struct channel __rcu *bridge; With RCU protection, it might make sense to use ->upl, instead of ->downl, to protect the update side. Since ->upl is used to protect the pointer to the parent unit, it probably makes sense to use it for ->bridge too, which somehow replaces the parent unit (as both are mutually exclusive). Also, using ->upl would avoid some lock nesting when updating ->bridge. > #ifdef CONFIG_PPP_MULTILINK > u8 avail; /* flag used in multilink stuff */ > u8 had_frag; /* >= 1 fragments have been sent */ > @@ -606,6 +607,95 @@ static struct bpf_prog *compat_ppp_get_filter(struct sock_fprog32 __user *p) > #endif > #endif > > +/* Bridge one PPP channel to another. > + * When two channels are bridged, ppp_input on one channel is redirected to > + * the other's ops->start_xmit handler. > + * In order to safely bridge channels we must reject channels which are already > + * part of a bridge instance, or which form part of an existing unit. > + * Once successfully bridged, each channel holds a reference on the other > + * to prevent it being freed while the bridge is extant. > + */ > +static int ppp_bridge_channels(struct channel *pch, struct channel *pchb) > +{ > + int ret = -EALREADY; > + > + /* We need to take each channel upl for access to the 'ppp' field, > + * and each channel downl for write access to the 'bridge' field. > + */ > + > + read_lock_bh(&pch->upl); > + if (pch->ppp) > + goto out0; > + > + spin_lock(&pch->downl); > + > + read_lock_bh(&pchb->upl); > + if (pchb->ppp) > + goto out1; You're verifying that ->ppp isn't set, however, you haven't added a test in ppp_connect_channel() to avoid setting ->ppp when ->bridge is already set. Therefore, it'd still be possible to set both ->ppp and ->bridge on a channel. > + spin_lock(&pchb->downl); > + > + if (pch->bridge || pchb->bridge) > + goto out2; > + > + rcu_assign_pointer(pch->bridge, pchb); > + refcount_inc(&pchb->file.refcnt); > + > + rcu_assign_pointer(pchb->bridge, pch); > + refcount_inc(&pch->file.refcnt); > + > + ret = 0; > + > +out2: > + spin_unlock(&pchb->downl); > +out1: > + read_unlock_bh(&pchb->upl); > + spin_unlock(&pch->downl); > +out0: > + read_unlock_bh(&pch->upl); > + > + return ret; > +} Locking looks dangerous here: given that ppp_bridge_channels() is called with pn->all_channels_lock held, that's 5 nested locks. Since we have to hold the channels anyway, why not incrementing the refcount immediately and unlock everything as soon as possible? That is, instead of doing: LOCK(all_channels_lock) LOCK(channel->upl) LOCK(channel->downl) LOCK(bridge->upl) LOCK(bridge->downl) assign_pointers UNLOCK() ... UNLOCK() what about something like: LOCK(all_channels_lock) bridge = find_channel() refcount_inc(&bridge->refcount) UNLOCK(all_channels_lock) LOCK(channel->upl) LOCK(channel->downl) set ->bridge UNLOCK(channel->downl) UNLOCK(channel->upl) refcount_inc(&channel->refcount) // so that bridge holds a ref LOCK(bridge->upl) LOCK(bridge->downl) set ->bridge UNLOCK(bridge->downl) UNLOCK(bridge->upl) We could even avoid locking ->downl if ->bridge was protected directly by ->upl. That way we'd avoid nesting locks entirely. > +static int ppp_unbridge_channels(struct channel *pch) > +{ > + struct channel *pchb; > + > + rcu_read_lock(); > + > + pchb = rcu_dereference(pch->bridge); > + if (!pchb) { > + rcu_read_unlock(); > + return -ENXIO; > + } > + > + if (pch != rcu_dereference(pchb->bridge)) { > + rcu_read_unlock(); > + return -ENXIO; > + } Looks like we have a TOCTOU problem here: ->bridge might change before we lock ->downl. > + spin_lock(&pch->downl); > + spin_lock(&pchb->downl); I think we can have a deadlock here. Since ppp_unbridge_channels() isn't running under the protection of an external lock, we could have the bridge channel call this function concurrently. Then we'd have lock inversion: ppp_unbridge_channels(channel) ppp_unbridge_channels(bridge) LOCK(channel->downl) LOCK(bridge->downl) LOCK(bridge->downl) LOCK(channel->downl) // deadlock Here again I think we should avoid nesting locks and clear each ->bridge pointer independently. > + rcu_assign_pointer(pch->bridge, NULL); > + rcu_assign_pointer(pchb->bridge, NULL); Nit, we can use RCU_INIT_POINTER() when resetting a pointer with NULL. > + spin_unlock(&pchb->downl); > + spin_unlock(&pch->downl); > + > + rcu_read_unlock(); > + > + synchronize_rcu(); > + > + if (refcount_dec_and_test(&pch->file.refcnt)) > + ppp_destroy_channel(pch); > + > + if (refcount_dec_and_test(&pchb->file.refcnt)) > + ppp_destroy_channel(pchb); > + > + return 0; > +} > + > static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > { > struct ppp_file *pf; > @@ -641,8 +731,9 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > } > > if (pf->kind == CHANNEL) { > - struct channel *pch; > + struct channel *pch, *pchb; > struct ppp_channel *chan; > + struct ppp_net *pn; > > pch = PF_TO_CHANNEL(pf); > > @@ -657,6 +748,22 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > err = ppp_disconnect_channel(pch); > break; > > + case PPPIOCBRIDGECHAN: > + if (get_user(unit, p)) > + break; > + err = -ENXIO; > + pn = ppp_pernet(current->nsproxy->net_ns); > + spin_lock_bh(&pn->all_channels_lock); > + pchb = ppp_find_channel(pn, unit); > + if (pchb) > + err = ppp_bridge_channels(pch, pchb); > + spin_unlock_bh(&pn->all_channels_lock); > + break; > + > + case PPPIOCUNBRIDGECHAN: > + err = ppp_unbridge_channels(pch); > + break; > + > default: > down_read(&pch->chan_sem); > chan = pch->chan; > @@ -2089,6 +2196,35 @@ static bool ppp_decompress_proto(struct sk_buff *skb) > return pskb_may_pull(skb, 2); > } > > +/* Attempt to handle a frame via. a bridged channel, if one exists. > + * If the channel is bridged, the frame is consumed by the bridge. > + * If not, the caller must handle the frame by normal recv mechanisms. > + * Returns true if the frame is consumed, false otherwise. > + */ > +static bool ppp_channel_bridge_input(struct channel *pch, struct sk_buff *skb) > +{ > + struct channel *pchb; > + > + rcu_read_lock(); > + pchb = rcu_dereference(pch->bridge); > + if (pchb) { > + spin_lock(&pchb->downl); > + if (pchb->chan) { > + skb_scrub_packet(skb, !net_eq(pch->chan_net, pchb->chan_net)); > + if (!pchb->chan->ops->start_xmit(pchb->chan, skb)) > + kfree_skb(skb); > + } else { > + /* channel got unregistered */ > + kfree_skb(skb); > + } > + spin_unlock(&pchb->downl); > + } > + rcu_read_unlock(); > + > + /* If pchb is set then we've consumed the packet */ > + return pchb; > +} Maybe "return !!pchb;". I always find it unexpected to store a pointer into a bool. But maybe it's just me. Also, I believe the code could be made more readable by returning early in unhandled cases, instead of nesting all the conditions. > void > ppp_input(struct ppp_channel *chan, struct sk_buff *skb) > { > @@ -2100,6 +2236,10 @@ ppp_input(struct ppp_channel *chan, struct sk_buff *skb) > return; > } > > + /* If the channel is bridged, transmit via. bridge */ > + if (ppp_channel_bridge_input(pch, skb)) > + return; > + > read_lock_bh(&pch->upl); > if (!ppp_decompress_proto(skb)) { > kfree_skb(skb); > @@ -2796,8 +2936,11 @@ ppp_unregister_channel(struct ppp_channel *chan) > list_del(&pch->list); > spin_unlock_bh(&pn->all_channels_lock); > > + ppp_unbridge_channels(pch); > + > pch->file.dead = 1; > wake_up_interruptible(&pch->file.rwait); > + > if (refcount_dec_and_test(&pch->file.refcnt)) > ppp_destroy_channel(pch); > } > diff --git a/include/uapi/linux/ppp-ioctl.h b/include/uapi/linux/ppp-ioctl.h > index 7bd2a5a75348..8dbecb3ad036 100644 > --- a/include/uapi/linux/ppp-ioctl.h > +++ b/include/uapi/linux/ppp-ioctl.h > @@ -115,6 +115,8 @@ struct pppol2tp_ioc_stats { > #define PPPIOCATTCHAN _IOW('t', 56, int) /* attach to ppp channel */ > #define PPPIOCGCHAN _IOR('t', 55, int) /* get ppp channel number */ > #define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats) > +#define PPPIOCBRIDGECHAN _IOW('t', 53, int) /* bridge one channel to another */ > +#define PPPIOCUNBRIDGECHAN _IO('t', 54) /* unbridge channel */ > > #define SIOCGPPPSTATS (SIOCDEVPRIVATE + 0) > #define SIOCGPPPVER (SIOCDEVPRIVATE + 1) /* NEVER change this!! */ > -- > 2.17.1 >
On Fri, Nov 27, 2020 at 20:31:34 +0100, Guillaume Nault wrote: > On Thu, Nov 26, 2020 at 12:24:25PM +0000, Tom Parkin wrote: > > This new ioctl pair allows two ppp channels to be bridged together: > > frames arriving in one channel are transmitted in the other channel > > and vice versa. > > Thanks! > Some comments below (mostly about locking). Thanks for your review Guillaume. I'll work on integrating your comments (and a fix for the build test robot warning) into a v2 series.
diff --git a/drivers/net/ppp/ppp_generic.c b/drivers/net/ppp/ppp_generic.c index 7d005896a0f9..5e563bfb8e2a 100644 --- a/drivers/net/ppp/ppp_generic.c +++ b/drivers/net/ppp/ppp_generic.c @@ -170,11 +170,12 @@ struct channel { struct list_head list; /* link in all/new_channels list */ struct ppp_channel *chan; /* public channel data structure */ struct rw_semaphore chan_sem; /* protects `chan' during chan ioctl */ - spinlock_t downl; /* protects `chan', file.xq dequeue */ + spinlock_t downl; /* protects `chan', 'bridge', file.xq dequeue */ struct ppp *ppp; /* ppp unit we're connected to */ struct net *chan_net; /* the net channel belongs to */ struct list_head clist; /* link in list of channels per unit */ rwlock_t upl; /* protects `ppp' */ + struct channel *bridge; /* "bridged" ppp channel */ #ifdef CONFIG_PPP_MULTILINK u8 avail; /* flag used in multilink stuff */ u8 had_frag; /* >= 1 fragments have been sent */ @@ -606,6 +607,95 @@ static struct bpf_prog *compat_ppp_get_filter(struct sock_fprog32 __user *p) #endif #endif +/* Bridge one PPP channel to another. + * When two channels are bridged, ppp_input on one channel is redirected to + * the other's ops->start_xmit handler. + * In order to safely bridge channels we must reject channels which are already + * part of a bridge instance, or which form part of an existing unit. + * Once successfully bridged, each channel holds a reference on the other + * to prevent it being freed while the bridge is extant. + */ +static int ppp_bridge_channels(struct channel *pch, struct channel *pchb) +{ + int ret = -EALREADY; + + /* We need to take each channel upl for access to the 'ppp' field, + * and each channel downl for write access to the 'bridge' field. + */ + + read_lock_bh(&pch->upl); + if (pch->ppp) + goto out0; + + spin_lock(&pch->downl); + + read_lock_bh(&pchb->upl); + if (pchb->ppp) + goto out1; + + spin_lock(&pchb->downl); + + if (pch->bridge || pchb->bridge) + goto out2; + + rcu_assign_pointer(pch->bridge, pchb); + refcount_inc(&pchb->file.refcnt); + + rcu_assign_pointer(pchb->bridge, pch); + refcount_inc(&pch->file.refcnt); + + ret = 0; + +out2: + spin_unlock(&pchb->downl); +out1: + read_unlock_bh(&pchb->upl); + spin_unlock(&pch->downl); +out0: + read_unlock_bh(&pch->upl); + + return ret; +} + +static int ppp_unbridge_channels(struct channel *pch) +{ + struct channel *pchb; + + rcu_read_lock(); + + pchb = rcu_dereference(pch->bridge); + if (!pchb) { + rcu_read_unlock(); + return -ENXIO; + } + + if (pch != rcu_dereference(pchb->bridge)) { + rcu_read_unlock(); + return -ENXIO; + } + + spin_lock(&pch->downl); + spin_lock(&pchb->downl); + + rcu_assign_pointer(pch->bridge, NULL); + rcu_assign_pointer(pchb->bridge, NULL); + + spin_unlock(&pchb->downl); + spin_unlock(&pch->downl); + + rcu_read_unlock(); + + synchronize_rcu(); + + if (refcount_dec_and_test(&pch->file.refcnt)) + ppp_destroy_channel(pch); + + if (refcount_dec_and_test(&pchb->file.refcnt)) + ppp_destroy_channel(pchb); + + return 0; +} + static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct ppp_file *pf; @@ -641,8 +731,9 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) } if (pf->kind == CHANNEL) { - struct channel *pch; + struct channel *pch, *pchb; struct ppp_channel *chan; + struct ppp_net *pn; pch = PF_TO_CHANNEL(pf); @@ -657,6 +748,22 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) err = ppp_disconnect_channel(pch); break; + case PPPIOCBRIDGECHAN: + if (get_user(unit, p)) + break; + err = -ENXIO; + pn = ppp_pernet(current->nsproxy->net_ns); + spin_lock_bh(&pn->all_channels_lock); + pchb = ppp_find_channel(pn, unit); + if (pchb) + err = ppp_bridge_channels(pch, pchb); + spin_unlock_bh(&pn->all_channels_lock); + break; + + case PPPIOCUNBRIDGECHAN: + err = ppp_unbridge_channels(pch); + break; + default: down_read(&pch->chan_sem); chan = pch->chan; @@ -2089,6 +2196,35 @@ static bool ppp_decompress_proto(struct sk_buff *skb) return pskb_may_pull(skb, 2); } +/* Attempt to handle a frame via. a bridged channel, if one exists. + * If the channel is bridged, the frame is consumed by the bridge. + * If not, the caller must handle the frame by normal recv mechanisms. + * Returns true if the frame is consumed, false otherwise. + */ +static bool ppp_channel_bridge_input(struct channel *pch, struct sk_buff *skb) +{ + struct channel *pchb; + + rcu_read_lock(); + pchb = rcu_dereference(pch->bridge); + if (pchb) { + spin_lock(&pchb->downl); + if (pchb->chan) { + skb_scrub_packet(skb, !net_eq(pch->chan_net, pchb->chan_net)); + if (!pchb->chan->ops->start_xmit(pchb->chan, skb)) + kfree_skb(skb); + } else { + /* channel got unregistered */ + kfree_skb(skb); + } + spin_unlock(&pchb->downl); + } + rcu_read_unlock(); + + /* If pchb is set then we've consumed the packet */ + return pchb; +} + void ppp_input(struct ppp_channel *chan, struct sk_buff *skb) { @@ -2100,6 +2236,10 @@ ppp_input(struct ppp_channel *chan, struct sk_buff *skb) return; } + /* If the channel is bridged, transmit via. bridge */ + if (ppp_channel_bridge_input(pch, skb)) + return; + read_lock_bh(&pch->upl); if (!ppp_decompress_proto(skb)) { kfree_skb(skb); @@ -2796,8 +2936,11 @@ ppp_unregister_channel(struct ppp_channel *chan) list_del(&pch->list); spin_unlock_bh(&pn->all_channels_lock); + ppp_unbridge_channels(pch); + pch->file.dead = 1; wake_up_interruptible(&pch->file.rwait); + if (refcount_dec_and_test(&pch->file.refcnt)) ppp_destroy_channel(pch); } diff --git a/include/uapi/linux/ppp-ioctl.h b/include/uapi/linux/ppp-ioctl.h index 7bd2a5a75348..8dbecb3ad036 100644 --- a/include/uapi/linux/ppp-ioctl.h +++ b/include/uapi/linux/ppp-ioctl.h @@ -115,6 +115,8 @@ struct pppol2tp_ioc_stats { #define PPPIOCATTCHAN _IOW('t', 56, int) /* attach to ppp channel */ #define PPPIOCGCHAN _IOR('t', 55, int) /* get ppp channel number */ #define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats) +#define PPPIOCBRIDGECHAN _IOW('t', 53, int) /* bridge one channel to another */ +#define PPPIOCUNBRIDGECHAN _IO('t', 54) /* unbridge channel */ #define SIOCGPPPSTATS (SIOCDEVPRIVATE + 0) #define SIOCGPPPVER (SIOCDEVPRIVATE + 1) /* NEVER change this!! */
This new ioctl pair allows two ppp channels to be bridged together: frames arriving in one channel are transmitted in the other channel and vice versa. The practical use for this is primarily to support the L2TP Access Concentrator use-case. The end-user session is presented as a ppp channel (typically PPPoE, although it could be e.g. PPPoA, or even PPP over a serial link) and is switched into a PPPoL2TP session for transmission to the LNS. At the LNS the PPP session is terminated in the ISP's network. When a PPP channel is bridged to another it takes a reference on the other's struct ppp_file. This reference is dropped when the channels are unbridged, which can occur either explicitly on userspace calling the PPPIOCUNBRIDGECHAN ioctl, or implicitly when either channel in the bridge is unregistered. In order to implement the channel bridge, struct channel is extended with a new field, 'bridge', which points to the other struct channel making up the bridge. This pointer is RCU protected to avoid adding another lock to the data path. To guard against concurrent writes to the pointer, the existing struct channel lock 'downl' use is extended (rather than adding a new lock). Order of lock acquisition is maintained: i.e. the channel 'upl' lock is always acquired before 'downl' in code paths that need to hold both. Signed-off-by: Tom Parkin <tparkin@katalix.com> --- drivers/net/ppp/ppp_generic.c | 147 ++++++++++++++++++++++++++++++++- include/uapi/linux/ppp-ioctl.h | 2 + 2 files changed, 147 insertions(+), 2 deletions(-)