eternalwrt-mt798x/target/linux/generic/files/drivers/leds/trigger/ledtrig-network.c

// SPDX-License-Identifier: GPL-2.0
/*
 * LED trigger for network interfaces.
 *
 * - Aggregated per-family (lan/wan/wlan).
 * - Family and flags are taken from device tree properties:
 *     - "family" : simple family string "lan" | "wan" | "wlan"
 *     - "mode"   : any combination of "link", "tx", "rx" flags
 *   Priority/combination:
 *     * If "mode" present: flags come from "mode" and take precedence.
 *       Family is taken from "family" if present, otherwise from the LED name.
 *     * If only "family" present: use its family and default flags = link+tx+rx.
 *     * If neither present: fall back to LED device name parsing.
 *
 * - Suffix "-online" is valid ONLY in the LED name (label), e.g. "green:wlan-online".
 *   It indicates the online variant but is applied only when DT "mode" is absent.
 *
 * Behaviour:
 * - wlan (normal): blink/solid driven by throughput table
 * - lan/wan (normal): one-shot blink on TX/RX packet change
 * - *-online variants: steady ON while any interface of the family has carrier
 *
 * Interfaces are auto-tracked by name match (lan0, wan1, wlan2, phy0, wl1, ath0, ra0...).
 * Up to MAX_IFACES (16) interfaces per family.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/leds.h>
#include <linux/mutex.h>
#include <linux/netdevice.h>
#include <linux/workqueue.h>
#include <linux/of.h>
#include <linux/list.h>
#include <linux/atomic.h>
#include <linux/compiler.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/device.h>
#include <linux/ctype.h>
#include <linux/err.h>
#include "../leds.h"

#define MAX_IFACES 16
#define DEFAULT_INTERVAL_MS 50
/* Work reschedule period = 2 * DEFAULT_INTERVAL_MS; named explicitly
 * to avoid silent divergence between the zero-iface and normal paths.
 */
#define WORK_INTERVAL_MS (2 * DEFAULT_INTERVAL_MS)

enum net_trig_type {
	NET_TRIG_LAN = 0,
	NET_TRIG_WAN,
	NET_TRIG_WLAN,
	NET_TRIG_TYPE_MAX,
};

static const char * const type_names[] = {
	[NET_TRIG_LAN] = "lan",
	[NET_TRIG_WAN] = "wan",
	[NET_TRIG_WLAN] = "wlan",
};

/* labels indexed by bitmask: (link<<2)|(tx<<1)|(rx<<0) */
static const char *const labels[] = {
	"",              /* 0 */
	"(rx)",          /* 1 */
	"(tx)",          /* 2 */
	"(tx rx)",       /* 3 */
	"(link)",        /* 4 */
	"(link rx)",     /* 5 */
	"(link tx)",     /* 6 */
	"(link tx rx)",  /* 7 */
};

/* wlan throughput table */
static const struct {
	u32 throughput;
	unsigned long on_ms;
	unsigned long off_ms;
} wlan_tpt_table[] = {
	{   64, 200, 800 },
	{  512, 200, 300 },
	{ 2048, 200, 150 },
	{10000, 200,  50 },
	{54000, 100,  50 },
};

struct net_mgr {
	enum net_trig_type type; /* family: lan/wan/wlan */

	struct mutex lock;
	struct notifier_block notifier;
	struct delayed_work work;

	struct net_device *devs[MAX_IFACES];
	int dev_slot_limit;

	u64 agg_tx_packets;
	u64 agg_rx_packets;
	u64 agg_tx_bytes;
	u64 agg_rx_bytes;

	struct list_head leds;
	atomic_t refcnt;
};

struct net_led {
	struct list_head node;
	struct led_classdev *led_cdev;
	struct net_mgr *mgr;

	u64 last_tx_packets;
	u64 last_rx_packets;
	u64 last_tx_bytes;
	u64 last_rx_bytes;

	bool link;
	bool tx;
	bool rx;
};

/*
 * Locking rules:
 * - managers_lock protects managers[] and entry->mgr reassignment.
 * - m->lock protects m->leds, m->devs[], agg_* and per-entry last_* while linked to m.
 * - Moving an entry between managers requires managers_lock and both manager locks.
 */
static DEFINE_MUTEX(managers_lock);
static struct net_mgr *managers[NET_TRIG_TYPE_MAX];

static ssize_t net_flag_show(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t net_flag_store(struct device *dev, struct device_attribute *attr,
			      const char *buf, size_t count);
static ssize_t net_dev_show(struct device *dev, struct device_attribute *attr, char *buf);
static ssize_t net_dev_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count);

/* helpers */
static inline void led_set_off_full(struct led_classdev *led, bool on)
{
	led_stop_software_blink(led);
	led_set_brightness(led, on ? LED_FULL : LED_OFF);
}

static inline void led_set_oneshot_ms(struct led_classdev *led, unsigned long ms, bool invert)
{
	led_stop_software_blink(led);
	led_blink_set_oneshot(led, &ms, &ms, invert);
}

static inline void net_mgr_lock_pair(struct net_mgr *a, struct net_mgr *b)
{
	if (a == b) {
		mutex_lock(&a->lock);
		return;
	}

	if ((unsigned long)a < (unsigned long)b) {
		mutex_lock(&a->lock);
		mutex_lock(&b->lock);
	} else {
		mutex_lock(&b->lock);
		mutex_lock(&a->lock);
	}
}

static inline void net_mgr_unlock_pair(struct net_mgr *a, struct net_mgr *b)
{
	if (a == b) {
		mutex_unlock(&a->lock);
		return;
	}

	if ((unsigned long)a < (unsigned long)b) {
		mutex_unlock(&b->lock);
		mutex_unlock(&a->lock);
	} else {
		mutex_unlock(&a->lock);
		mutex_unlock(&b->lock);
	}
}

/* helper: check that next char after prefix is digit, '-' or NUL */
static inline bool next_char_ok(const char *s, size_t pos)
{
	char c = s[pos];
	return c == '\0' || c == '-' || (c >= '0' && c <= '9');
}

/* name matching: lan/wan; wlan matched by various wifi prefixes with restriction
 * additionally accept ath (Atheros) and ra/rai (Ralink/MediaTek) prefixes.
 * For lan and wan require next char to be digit/'-' or end to avoid accidental matches.
 */
static bool name_matches_type(const char *name, enum net_trig_type type)
{
	if (!name)
		return false;

	switch (type) {
	case NET_TRIG_LAN:
		/* accept "lan", "lanX", "lan-X" */
		if (!strncmp(name, "lan", 3))
			return next_char_ok(name, 3);
		return false;

	case NET_TRIG_WAN:
		/* accept "wan", "wanX", "wan-X" */
		if (!strncmp(name, "wan", 3))
			return next_char_ok(name, 3);
		return false;

	case NET_TRIG_WLAN:
		/* accept "phyX", "wlX"/"wl-..." or "wlan" and common driver prefixes */
		if (!strncmp(name, "phy", 3))
			return next_char_ok(name, 3);
		if (!strncmp(name, "wlan", 4))
			return next_char_ok(name, 4);
		if (!strncmp(name, "wl", 2))
			return next_char_ok(name, 2);
		/* Atheros (athX) */
		if (!strncmp(name, "ath", 3))
			return next_char_ok(name, 3);
		/* Ralink/MediaTek: check "rai" (e.g. rai0) first, then "ra" (ra0) */
		if (!strncmp(name, "rai", 3))
			return next_char_ok(name, 3);
		if (!strncmp(name, "ra", 2))
			return next_char_ok(name, 2);
		return false;

	default:
		return false;
	}
}

/* Extract family type (lan/wan/wlan) from a string.
 * If "online" is supplied, also detects and strips the "-online" suffix.
 * Returns enum net_trig_type or -1 on error.
 */
static int parse_family_token(const char *fn, bool *online)
{
	size_t len;
	const size_t sufflen = sizeof("-online") - 1;

	if (online)
		*online = false;

	if (!fn)
		return -1;

	len = strlen(fn);

	if (online && (len > sufflen) && !strcmp(fn + len - sufflen, "-online")) {
		*online = true;
		len -= sufflen;
	}

	if (len == 3 && !strncmp(fn, "lan", 3))
		return NET_TRIG_LAN;
	if (len == 3 && !strncmp(fn, "wan", 3))
		return NET_TRIG_WAN;
	if (len == 4 && !strncmp(fn, "wlan", 4))
		return NET_TRIG_WLAN;

	return -1;
}

/* Parse only flags from a string: recognized tokens are "link", "tx", "rx".
 * Any other token => -EINVAL. If no flags found, set all three true.
 * Suitable for DT "mode" (strict) or parsing flags from name when no mode present.
 */
static int parse_flags_from_string(const char *fn, bool *link, bool *tx, bool *rx)
{
	size_t len;
	const char *buf = NULL;
	size_t buflen = 0;
	size_t i;
	bool found = false;

	if (!fn || !link || !tx || !rx)
		return -EINVAL;

	*link = false;
	*tx = false;
	*rx = false;

	len = strlen(fn);
	for (i = 0; i < len; i++) {
		if (fn[i] == ' ' || fn[i] == '\t' || fn[i] == ',') {
			buf = NULL;
			buflen = 0;
			continue;
		}

		if (!buf) {
			buf = fn + i;
			buflen = 0;
		}
		buflen++;

		if ((i + 1 == len) || fn[i + 1] == ' ' || fn[i + 1] == '\t' || fn[i + 1] == ',') {
			if (buflen == 4 && !strncmp(buf, "link", 4)) {
				*link = true;
				found = true;
			} else if (buflen == 2 && !strncmp(buf, "tx", 2)) {
				*tx = true;
				found = true;
			} else if (buflen == 2 && !strncmp(buf, "rx", 2)) {
				*rx = true;
				found = true;
			} else {
				/* unknown token */
				return -EINVAL;
			}

			buf = NULL;
			buflen = 0;
		}
	}

	/* default: if no flags found, set all true */
	if (!found) {
		*link = true;
		*tx = true;
		*rx = true;
	}

	return 0;
}

/* safe stats read wrapper */
static void get_dev_stats_safe(struct net_device *dev, struct rtnl_link_stats64 *st)
{
	memset(st, 0, sizeof(*st));
	dev_get_stats(dev, st);
}

/* Update single LED according to manager aggregates and per-LED flags.
 * any_online indicates whether any tracked interface currently has carrier.
 * If LED is online-only (link && !tx && !rx) it is driven directly by any_online.
 */
static void update_led(struct net_led *e, struct net_mgr *m, bool any_online)
{
	unsigned long on_ms, off_ms;
	struct led_classdev *led = e->led_cdev;

	/* defensive: avoid deref if led unexpectedly NULL */
	if (!led)
		return;

	/* If LED requested online-only, reflect any_online */
	if (READ_ONCE(e->link) && !READ_ONCE(e->tx) && !READ_ONCE(e->rx)) {
		led_set_off_full(led, any_online);
		return;
	}

	/* For non-online-only LEDs: if no tracked interface has carrier,
	 * keep the LED off and reset history baseline to avoid spurious deltas
	 * when carrier later returns.
	 */
	if (!any_online) {
		led_set_off_full(led, false);

		e->last_tx_packets = m->agg_tx_packets;
		e->last_rx_packets = m->agg_rx_packets;
		e->last_tx_bytes = m->agg_tx_bytes;
		e->last_rx_bytes = m->agg_rx_bytes;
		return;
	}

	/* non-online-only behaviour depends on family */
	if (m->type == NET_TRIG_WLAN) {
		/* throughput-driven */
		u64 bytes_delta = 0;
		u64 kbps = 0;
		int idx = 0;
		int t;

		if (READ_ONCE(e->tx) && m->agg_tx_bytes >= e->last_tx_bytes)
			bytes_delta += m->agg_tx_bytes - e->last_tx_bytes;
		if (READ_ONCE(e->rx) && m->agg_rx_bytes >= e->last_rx_bytes)
			bytes_delta += m->agg_rx_bytes - e->last_rx_bytes;

		/* Avoid overflow when multiplying bytes_delta; cap to max u64. */
		if (bytes_delta > ULLONG_MAX / 8)
			kbps = ULLONG_MAX;
		else
			kbps = div64_u64(bytes_delta * 8, WORK_INTERVAL_MS);

		if (kbps == 0) {
			led_set_off_full(led, READ_ONCE(e->link));
		} else {
			for (t = 0; t < ARRAY_SIZE(wlan_tpt_table); t++) {
				if (kbps >= wlan_tpt_table[t].throughput)
					idx = t;
				else
					break;
			}

			on_ms = wlan_tpt_table[idx].on_ms;
			off_ms = wlan_tpt_table[idx].off_ms;
			if (READ_ONCE(e->link))
				led_blink_set(led, &on_ms, &off_ms);
			else
				led_blink_set(led, &off_ms, &on_ms);
		}

		e->last_tx_bytes = m->agg_tx_bytes;
		e->last_rx_bytes = m->agg_rx_bytes;
	} else {
		/* LAN/WAN: oneshot on packet-count change */
		u64 tx_sum = m->agg_tx_packets;
		u64 rx_sum = m->agg_rx_packets;

		if ((READ_ONCE(e->tx) && tx_sum != e->last_tx_packets) ||
		    (READ_ONCE(e->rx) && rx_sum != e->last_rx_packets)) {
			unsigned long ms = DEFAULT_INTERVAL_MS;

			led_set_oneshot_ms(led, ms, READ_ONCE(e->link));
		} else {
			led_set_off_full(led, READ_ONCE(e->link));
		}

		e->last_tx_packets = tx_sum;
		e->last_rx_packets = rx_sum;
	}
}

/* Three-stage work: snapshot devices, collect stats, update LEDs.
 * Stats are collected without m->lock to avoid lock inversion with the
 * network stack (dev_get_stats may acquire driver locks / send notifiers).
 */
static void net_mgr_work(struct work_struct *work)
{
	struct net_mgr *m = container_of(work, struct net_mgr, work.work);
	struct net_device *snap[MAX_IFACES];
	int snap_count = 0;
	u64 agg_tx_packets = 0, agg_rx_packets = 0;
	u64 agg_tx_bytes = 0, agg_rx_bytes = 0;
	bool any_online = false;
	struct net_led *e;
	int i;

	/* Stage 1: snapshot device references under m->lock. */
	mutex_lock(&m->lock);
	for (i = 0; i < m->dev_slot_limit; i++) {
		if (m->devs[i]) {
			snap[snap_count] = m->devs[i];
			dev_hold(snap[snap_count]);
			snap_count++;
		}
	}
	mutex_unlock(&m->lock);

	/* Stage 2: collect stats without m->lock.
	 * Devices are pinned by dev_hold from stage 1.
	 */
	for (i = 0; i < snap_count; i++) {
		struct net_device *dev = snap[i];
		struct rtnl_link_stats64 st;

		get_dev_stats_safe(dev, &st);
		agg_tx_packets += st.tx_packets;
		agg_rx_packets += st.rx_packets;
		agg_tx_bytes   += st.tx_bytes;
		agg_rx_bytes   += st.rx_bytes;

		if (netif_running(dev) && netif_carrier_ok(dev))
			any_online = true;

		dev_put(dev);
	}

	/* Stage 3: update aggregates and LEDs under m->lock.
	 * Note: any_online was sampled in stage 2 without m->lock, so it may
	 * lag reality by up to one WORK_INTERVAL_MS cycle. This is acceptable
	 * for LED visual purposes.
	 */
	mutex_lock(&m->lock);

	m->agg_tx_packets = agg_tx_packets;
	m->agg_rx_packets = agg_rx_packets;
	m->agg_tx_bytes   = agg_tx_bytes;
	m->agg_rx_bytes   = agg_rx_bytes;

	list_for_each_entry(e, &m->leds, node)
		update_led(e, m, any_online);

	mutex_unlock(&m->lock);

	schedule_delayed_work(&m->work, msecs_to_jiffies(WORK_INTERVAL_MS));
}

/* Remove device and compact trailing NULLs in devs[].
 * Caller must hold m->lock (or other serializing lock)!
 */
static void net_mgr_remove_dev(struct net_mgr *m, int hole)
{
	int last = m->dev_slot_limit - 1;

	/* Trim trailing NULL slots first */
	while (last > hole && !m->devs[last]) {
		last--;
		m->dev_slot_limit--;
	}

	if (last > hole) {
		/* Swap hole with last non-NULL slot */
		m->devs[hole] = m->devs[last];
		m->devs[last] = NULL;
	}
	/* last == hole: the hole is the last slot; just shrink */
	m->dev_slot_limit--;
}

/* notifier: manage tracked devices */
static int net_mgr_notify(struct notifier_block *nb, unsigned long event, void *ptr)
{
	struct netdev_notifier_info *info = ptr;
	struct net_device *dev = NULL;
	/* to_put collects any reference that must be dropped after mutex release */
	struct net_device *to_put = NULL;
	struct net_mgr *m = container_of(nb, struct net_mgr, notifier);
	int i, id = -1, newid;

	if (event != NETDEV_REGISTER && event != NETDEV_UNREGISTER &&
	    event != NETDEV_CHANGENAME)
		return NOTIFY_DONE;

	if (!info)
		return NOTIFY_DONE;

	dev = info->dev;
	if (!dev)
		return NOTIFY_DONE;

	mutex_lock(&m->lock);
	for (i = 0; i < m->dev_slot_limit; i++) {
		if (m->devs[i] == dev) {
			id = i;
			break;
		}
	}

	switch (event) {
	case NETDEV_UNREGISTER:
		if (id >= 0 && m->devs[id]) {
			to_put = m->devs[id];
			m->devs[id] = NULL;
			pr_info("%s - interface %s unregistered\n",
				type_names[m->type], dev->name);
			net_mgr_remove_dev(m, id);
		}
		break;

	case NETDEV_CHANGENAME:
		if (id >= 0 && !name_matches_type(dev->name, m->type)) {
			if (m->devs[id]) {
				to_put = m->devs[id];
				m->devs[id] = NULL;
				pr_info("%s - interface renamed to %s (no longer matches), untracked\n",
					type_names[m->type], dev->name);
				net_mgr_remove_dev(m, id);
			}
			break;
		}
		fallthrough;

	case NETDEV_REGISTER:
		if (id < 0 && name_matches_type(dev->name, m->type)) {
			newid = -1;
			for (i = 0; i < m->dev_slot_limit; i++) {
				if (!m->devs[i]) {
					newid = i;
					break;
				}
			}
			if (newid < 0 && m->dev_slot_limit < MAX_IFACES)
				newid = m->dev_slot_limit++;

			if (newid >= 0) {
				dev_hold(dev);
				m->devs[newid] = dev;
				pr_info("%s - interface %s registered\n",
					type_names[m->type], dev->name);
			}
		}
		break;
	}

	mutex_unlock(&m->lock);

	/* drop reference outside the lock to avoid lock inversion */
	if (to_put)
		dev_put(to_put);

	return NOTIFY_DONE;
}

static void net_mgr_put(struct net_mgr *m)
{
	int i;

	if (!m)
		return;

	if (!atomic_dec_and_mutex_lock(&m->refcnt, &managers_lock))
		return;

	if (managers[m->type] == m)
		managers[m->type] = NULL;
	mutex_unlock(&managers_lock);

	cancel_delayed_work_sync(&m->work);
	unregister_netdevice_notifier(&m->notifier);

	mutex_lock(&m->lock);
	for (i = 0; i < m->dev_slot_limit; i++) {
		if (m->devs[i])
			dev_put(m->devs[i]);
	}
	mutex_unlock(&m->lock);

	kfree(m);
}

/* find/create manager for base family */
static struct net_mgr *net_mgr_get(enum net_trig_type type)
{
	struct net_mgr *m, *existing = NULL;
	int i;

	if (type >= NET_TRIG_TYPE_MAX)
		return NULL;

	/* fast-path: if already exists, bump ref and return */
	mutex_lock(&managers_lock);
	m = managers[type];
	if (m) {
		atomic_inc(&m->refcnt);
		mutex_unlock(&managers_lock);
		return m;
	}
	mutex_unlock(&managers_lock);

	/* allocate and init (not yet published) */
	m = kzalloc(sizeof(*m), GFP_KERNEL);
	if (!m)
		return NULL;

	m->type = type;
	mutex_init(&m->lock);
	INIT_LIST_HEAD(&m->leds);
	atomic_set(&m->refcnt, 1);
	INIT_DELAYED_WORK(&m->work, net_mgr_work);

	m->notifier.notifier_call = net_mgr_notify;
	m->notifier.priority = 0;

	if (register_netdevice_notifier(&m->notifier)) {
		kfree(m);
		return NULL;
	}

	/* publish manager, handle rare race where another thread created it first */
	mutex_lock(&managers_lock);
	existing = managers[type];
	if (existing) {
		/* use existing one: increase refcount, drop our allocation & deregister our (not-used) notifier */
		atomic_inc(&existing->refcnt);
		mutex_unlock(&managers_lock);
		unregister_netdevice_notifier(&m->notifier); /* deregister only our own! */
		for (i = 0; i < m->dev_slot_limit; i++) {
			if (m->devs[i])
				dev_put(m->devs[i]);
		}
		kfree(m);
		return existing;
	}

	managers[type] = m;
	mutex_unlock(&managers_lock);

	/* start background work */
	schedule_delayed_work(&m->work, 0);

	return m;
}

static DEVICE_ATTR(link, 0644, net_flag_show, net_flag_store);
static DEVICE_ATTR(tx, 0644, net_flag_show, net_flag_store);
static DEVICE_ATTR(rx, 0644, net_flag_show, net_flag_store);
static DEVICE_ATTR(family, 0644, net_dev_show, net_dev_store);

static struct attribute *net_attrs[] = {
	&dev_attr_link.attr,
	&dev_attr_tx.attr,
	&dev_attr_rx.attr,
	&dev_attr_family.attr,
	NULL,
};

static const struct attribute_group net_attr_group = {
	.attrs = net_attrs,
};

static ssize_t net_flag_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct net_led *entry;
	int val;

	entry = led_trigger_get_drvdata(dev);
	if (!entry)
		return -ENODEV;

	if (attr == &dev_attr_link)
		val = READ_ONCE(entry->link);
	else if (attr == &dev_attr_tx)
		val = READ_ONCE(entry->tx);
	else if (attr == &dev_attr_rx)
		val = READ_ONCE(entry->rx);
	else
		return -EINVAL;

	return sysfs_emit(buf, "%d\n", val);
}

static ssize_t net_flag_store(struct device *dev, struct device_attribute *attr,
			      const char *buf, size_t count)
{
	struct net_led *entry;
	struct net_mgr *mgr;
	bool val;
	int ret;

	entry = led_trigger_get_drvdata(dev);
	if (!entry)
		return -ENODEV;

	ret = kstrtobool(buf, &val);
	if (ret)
		return ret;

	/* Pin mgr via refcnt to prevent UAF.
	 * Hold managers_lock across the flag write so that net_dev_store()
	 * cannot reassign entry->mgr concurrently.
	 */
	mutex_lock(&managers_lock);
	mgr = entry->mgr;
	if (!mgr || !atomic_inc_not_zero(&mgr->refcnt)) {
		mutex_unlock(&managers_lock);
		return -ENODEV;
	}

	mutex_lock(&mgr->lock);

	if (attr == &dev_attr_link)
		WRITE_ONCE(entry->link, val);
	else if (attr == &dev_attr_tx)
		WRITE_ONCE(entry->tx, val);
	else if (attr == &dev_attr_rx)
		WRITE_ONCE(entry->rx, val);
	else {
		mutex_unlock(&mgr->lock);
		mutex_unlock(&managers_lock);
		net_mgr_put(mgr);
		return -EINVAL;
	}

	ret = count;

	pr_info("LED %s - network trigger flags changed to %s%s%s\n",
		dev_name(entry->led_cdev->dev),
		READ_ONCE(entry->link) ? "link " : "",
		READ_ONCE(entry->tx) ? "tx " : "",
		READ_ONCE(entry->rx) ? "rx" : "");

	mutex_unlock(&mgr->lock);
	mutex_unlock(&managers_lock);

	schedule_delayed_work(&mgr->work, 0);
	net_mgr_put(mgr);

	return ret;
}

static ssize_t net_dev_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct net_led *entry;
	struct net_mgr *mgr;
	ssize_t ret;

	entry = led_trigger_get_drvdata(dev);
	if (!entry)
		return -ENODEV;

	/* Protect dereference with managers_lock and refcount */
	mutex_lock(&managers_lock);
	mgr = entry->mgr;
	if (mgr && !atomic_inc_not_zero(&mgr->refcnt))
		mgr = NULL;
	mutex_unlock(&managers_lock);

	if (!mgr)
		return -ENODEV;

	ret = sysfs_emit(buf, "%s\n", type_names[mgr->type]);
	net_mgr_put(mgr);
	return ret;
}

static ssize_t net_dev_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	char tmp[32];
	char *trimmed;
	size_t len = count;
	struct net_led *entry;
	int parsed;
	struct net_mgr *old_mgr = NULL, *new_mgr;
	size_t i;

	entry = led_trigger_get_drvdata(dev);
	if (!entry)
		return -ENODEV;

	/* Pin old_mgr via refcnt to prevent UAF */
	mutex_lock(&managers_lock);
	old_mgr = entry->mgr;
	if (old_mgr && !atomic_inc_not_zero(&old_mgr->refcnt))
		old_mgr = NULL;
	mutex_unlock(&managers_lock);
	if (!old_mgr)
		return -ENODEV;

	if (len == 0 || len >= sizeof(tmp)) {
		net_mgr_put(old_mgr);
		return -EINVAL;
	}

	/* copy raw input from sysfs buffer and ensure null-termination */
	memcpy(tmp, buf, len);
	tmp[len] = '\0';

	/* trim leading/trailing spaces, tabs, and newlines (\r, \n) */
	trimmed = strim(tmp);
	len = strlen(trimmed);

	/* reject internal spaces/tabs inside the token */
	for (i = 0; i < len; i++) {
		if (trimmed[i] == ' ' || trimmed[i] == '\t') {
			net_mgr_put(old_mgr);
			return -EINVAL;
		}
	}

	parsed = parse_family_token(trimmed, NULL);
	if (parsed < 0) {
		net_mgr_put(old_mgr);
		return -EINVAL;
	}

	if (old_mgr->type == parsed) {
		net_mgr_put(old_mgr);
		return count; /* no change */
	}

	/* get or create new manager (increments refcnt) */
	new_mgr = net_mgr_get(parsed);
	if (!new_mgr) {
		net_mgr_put(old_mgr);
		return -ENOMEM;
	}

	/* Move entry between manager lists.
	 * managers_lock serializes entry->mgr reassignment against all other paths.
	 * Both manager locks are required because both old_mgr->leds and new_mgr->leds
	 * are accessed by net_mgr_work() under the respective manager lock.
	 */
	mutex_lock(&managers_lock);
	net_mgr_lock_pair(old_mgr, new_mgr);

	/* Verify entry still belongs to old_mgr */
	if (entry->mgr != old_mgr) {
		net_mgr_unlock_pair(old_mgr, new_mgr);
		mutex_unlock(&managers_lock);
		net_mgr_put(new_mgr);
		net_mgr_put(old_mgr);
		return -ENODEV;
	}

	list_del(&entry->node);
	list_add_tail(&entry->node, &new_mgr->leds);
	entry->mgr = new_mgr;

	/* initialize history so future reads won't see a spurious delta */
	entry->last_tx_packets = new_mgr->agg_tx_packets;
	entry->last_rx_packets = new_mgr->agg_rx_packets;
	entry->last_tx_bytes = new_mgr->agg_tx_bytes;
	entry->last_rx_bytes = new_mgr->agg_rx_bytes;

	pr_info("LED %s - network trigger family changed to %s\n",
		dev_name(entry->led_cdev->dev), type_names[parsed]);

	net_mgr_unlock_pair(old_mgr, new_mgr);
	mutex_unlock(&managers_lock);

	schedule_delayed_work(&new_mgr->work, 0);

	/* Two puts for old_mgr:
	 * (1) the local pin acquired by atomic_inc_not_zero() at the top.
	 * (2) the structural ref that entry->mgr held for old_mgr,
	 *     which is now orphaned because entry->mgr was reassigned to new_mgr
	 *     (new_mgr's ref came from net_mgr_get() and was adopted by entry->mgr).
	 */
	net_mgr_put(old_mgr); /* (1) local pin */
	net_mgr_put(old_mgr); /* (2) structural ref from old entry->mgr */

	return count;
}

/* deactivate: detach led from manager */
static void net_deactivate(struct led_classdev *led_cdev)
{
	struct net_led *entry;
	struct net_mgr *m;

	entry = led_trigger_get_drvdata(led_cdev->dev);
	if (!entry)
		return;

	mutex_lock(&managers_lock);
	m = entry->mgr;
	if (!m || !atomic_inc_not_zero(&m->refcnt)) {
		mutex_unlock(&managers_lock);
		led_set_trigger_data(led_cdev, NULL);
		kfree(entry);
		return;
	}

	/* managers_lock is held continuously from above until after list_del,
	 * so entry->mgr cannot be reassigned by net_dev_store() concurrently.
	 * No re-verify needed.
	 */
	mutex_lock(&m->lock);
	list_del(&entry->node);
	entry->mgr = NULL;
	mutex_unlock(&m->lock);
	mutex_unlock(&managers_lock);

	led_set_off_full(led_cdev, false);
	led_set_trigger_data(led_cdev, NULL);

	pr_info("LED %s - trigger %s%s detached\n",
		dev_name(led_cdev->dev),
		type_names[m->type],
		labels[(READ_ONCE(entry->link) << 2) |
		       (READ_ONCE(entry->tx) << 1) |
		       (READ_ONCE(entry->rx) << 0)]);

	kfree(entry);
	net_mgr_put(m);		/* structural ref transferred from entry */
	net_mgr_put(m);		/* local pin taken above */
}

/* activate/deactivate: attach led to manager and remember flags */
static int net_activate(struct led_classdev *led_cdev)
{
	const char *fn = NULL;
	const char *dt_family = NULL;
	const char *dt_mode = NULL;
	int parsed = -1;
	bool link = false;
	bool tx = false;
	bool rx = false;
	bool online;
	struct net_mgr *m;
	struct net_led *entry;
	const char *name;
	const char *sep;
	int ret;

	if (!led_cdev) {
		pr_err("network: net_activate called with NULL led_cdev\n");
		return -EINVAL;
	}
	if (!led_cdev->dev) {
		pr_err("network: LED device is NULL, aborting activate\n");
		return -EINVAL;
	}

	name = dev_name(led_cdev->dev);
	if (!name || !*name) {
		pr_err("network: LED has no name, aborting activate\n");
		return -EINVAL;
	}

	if (led_trigger_get_drvdata(led_cdev->dev)) {
		pr_warn("network: LED %s already has trigger_data set, refusing attach\n",
			name);
		return -EBUSY;
	}

	if (led_cdev->dev->of_node) {
		of_property_read_string(led_cdev->dev->of_node, "family", &dt_family);
		of_property_read_string(led_cdev->dev->of_node, "mode", &dt_mode);
	}

	/* function part from name (after last ':') */
	sep = strrchr(name, ':');
	if (sep && sep[1] != '\0')
		fn = sep + 1;
	else
		fn = name;

	if (dt_mode) {
		/* DT mode present: strict parsing, empty string is invalid */
		if (*dt_mode == '\0')
			return -EINVAL;

		ret = parse_flags_from_string(dt_mode, &link, &tx, &rx);
		if (ret)
			return -EINVAL;

		/* family: from dt_family if present, otherwise from name */
		if (dt_family) {
			parsed = parse_family_token(dt_family, NULL);
			if (parsed < 0) {
				pr_info("network: invalid family '%s' for LED %s\n",
					dt_family, name);
				return -EINVAL;
			}
		} else {
			/* parse family from name; online flag parsed but not used here */
			parsed = parse_family_token(fn, &online);
			if (parsed < 0) {
				pr_info("network: no family in name and no family for LED %s\n",
					name);
				return -EINVAL;
			}
		}
	} else if (dt_family) {
		/* Only dt_family present: use its family. Flags depend on name "-online" */
		parsed = parse_family_token(dt_family, NULL);
		if (parsed < 0) {
			pr_info("network: invalid family '%s' for LED %s\n",
				dt_family, name);
			return -EINVAL;
		}

		/* test whether name contains "-online" */
		parse_family_token(fn, &online);
		if (online) {
			/* name indicated online variant and no mode -> online-only */
			link = true;
			tx = false;
			rx = false;
		} else {
			link = true;
			tx = true;
			rx = true;
		}
	} else {
		/* No DT properties: family and flags come from the LED name.
		 * If name had "-online" -> online-only.
		 */
		parsed = parse_family_token(fn, &online);
		if (parsed < 0) {
			pr_warn("network: cannot infer family from '%s' for LED %s, defaulting to 'wlan'\n",
				fn ?: "<NULL>", name);
			parsed = NET_TRIG_WLAN;
		}

		if (online) {
			/* online variant in name => online-only */
			link = true;
			tx = false;
			rx = false;
		} else {
			link = true;
			tx = true;
			rx = true;
		}
	}

	m = net_mgr_get(parsed);
	if (!m)
		return -ENOMEM;

	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	if (!entry) {
		net_mgr_put(m);
		return -ENOMEM;
	}

	entry->led_cdev = led_cdev;
	entry->mgr = m;
	entry->last_tx_packets = 0;
	entry->last_rx_packets = 0;
	entry->last_tx_bytes = 0;
	entry->last_rx_bytes = 0;
	WRITE_ONCE(entry->link, link);
	WRITE_ONCE(entry->tx, tx);
	WRITE_ONCE(entry->rx, rx);

	/* attach under manager lock and initialize history to current aggregates */
	mutex_lock(&m->lock);
	list_add_tail(&entry->node, &m->leds);

	/* initialize history so future reads won't see a spurious delta */
	entry->last_tx_packets = m->agg_tx_packets;
	entry->last_rx_packets = m->agg_rx_packets;
	entry->last_tx_bytes = m->agg_tx_bytes;
	entry->last_rx_bytes = m->agg_rx_bytes;
	mutex_unlock(&m->lock);

	/* Publish trigger data after entry is fully linked into the manager list.
	 * net_deactivate() relies on entry being on the list before list_del().
	 * Any sysfs access before this point returns -ENODEV, which is safe.
	 */
	led_set_trigger_data(led_cdev, entry);

	pr_info("LED %s - trigger %s%s attached\n",
		name,
		type_names[m->type],
		labels[(READ_ONCE(entry->link) << 2) |
		       (READ_ONCE(entry->tx) << 1) |
		       (READ_ONCE(entry->rx) << 0)]);

	return 0;
}

static struct led_trigger network_trigger = {
	.name = "network",
	.activate = net_activate,
	.deactivate = net_deactivate,
	/* Use .groups + led_trigger_get_drvdata/set_drvdata; avoid device_create_file/remove_file. */
	.groups = (const struct attribute_group *[]) { &net_attr_group, NULL },
};

module_led_trigger(network_trigger);

MODULE_AUTHOR("Mieczyslaw Nalewaj <namiltd@yahoo.com>");
MODULE_DESCRIPTION("LED trigger for network interfaces - aggregated by family; supports link/tx/rx and -online");
MODULE_LICENSE("GPL");