fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-09 03:38:09 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

platform: rename NMPRouteManager to NMPGlobalTracker

Browse source 
NetworkManager primarily manages interfaces in an independent fashion.
That means, whenever possible, we want to have a interface specific
view. In many cases, the underlying kernel API also supports that view.
For example, when configuring IP addresses or unicast routes, we do so
per interfaces and don't need a holistic view.

However, that is not always sufficient. For routing rules and certain
route types (blackhole, unreachable, etc), we need a system wide view
of all the objects in the network namespace.

Originally, NMPRulesManager was added to track routing rules. Then, it
was extended to also track certain route types, and the API was renamed to
NMPRouteManager.

This will also be used to track MPTCP addresses.

So rename again, to give it a general name that is suitable for what it
does. Still, the name is not great (suggestion welcome), but it should
cover the purpose of the API well enough. And it's the best I came
up with.

Rename.
This commit is contained in:
Thomas Haller 2022-07-18 09:12:09 +02:00
parent e466ad62e5
commit bf248e0400
No known key found for this signature in database
GPG key ID: 29C2366E4DFC5728
8 changed files with 274 additions and 270 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/core/devices/nm-device.c
View file

@ -9491,13 +9491,13 @@ lldp_setup(NMDevice *self, NMTernary enabled)
static void static void
_routing_rules_sync(NMDevice *self, NMTernary set_mode) _routing_rules_sync(NMDevice *self, NMTernary set_mode)
{ {
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self); NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self);
NMPRouteManager *route_manager = nm_netns_get_route_manager(nm_device_get_netns(self)); NMPGlobalTracker *global_tracker = nm_netns_get_global_tracker(nm_device_get_netns(self));
NMDeviceClass *klass = NM_DEVICE_GET_CLASS(self); NMDeviceClass *klass = NM_DEVICE_GET_CLASS(self);
gboolean untrack_only_dirty = FALSE; gboolean untrack_only_dirty = FALSE;
gboolean keep_deleted_rules; gboolean keep_deleted_rules;
gpointer user_tag_1; gpointer user_tag_1;
gpointer user_tag_2; gpointer user_tag_2;
/* take two arbitrary user-tag pointers that belong to @self. */ /* take two arbitrary user-tag pointers that belong to @self. */
user_tag_1 = &priv->v4_route_table; user_tag_1 = &priv->v4_route_table;
@ -9529,13 +9529,13 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
nm_ip_routing_rule_to_platform(rule, &plrule); nm_ip_routing_rule_to_platform(rule, &plrule);
/* We track this rule, but we also make it explicitly not weakly-tracked /* We track this rule, but we also make it explicitly not weakly-tracked
* (meaning to untrack NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG at * (meaning to untrack NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG at
* the same time). */ * the same time). */
nmp_route_manager_track_rule(route_manager, nmp_global_tracker_track_rule(global_tracker,
&plrule, &plrule,
10, 10,
user_tag_1, user_tag_1,
NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG); NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG);
} }
} }
@ -9545,25 +9545,25 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
extra_rules = klass->get_extra_rules(self); extra_rules = klass->get_extra_rules(self);
if (extra_rules) { if (extra_rules) {
for (i = 0; i < extra_rules->len; i++) { for (i = 0; i < extra_rules->len; i++) {
nmp_route_manager_track_rule( nmp_global_tracker_track_rule(
route_manager, global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(extra_rules->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(extra_rules->pdata[i]),
10, 10,
user_tag_2, user_tag_2,
NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG); NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG);
} }
} }
} }
} }
nmp_route_manager_untrack_all(route_manager, user_tag_1, !untrack_only_dirty, TRUE); nmp_global_tracker_untrack_all(global_tracker, user_tag_1, !untrack_only_dirty, TRUE);
if (klass->get_extra_rules) if (klass->get_extra_rules)
nmp_route_manager_untrack_all(route_manager, user_tag_2, !untrack_only_dirty, TRUE); nmp_global_tracker_untrack_all(global_tracker, user_tag_2, !untrack_only_dirty, TRUE);
keep_deleted_rules = FALSE; keep_deleted_rules = FALSE;
if (set_mode == NM_TERNARY_DEFAULT) { if (set_mode == NM_TERNARY_DEFAULT) {
/* when exiting NM, we leave the device up and the rules configured. /* when exiting NM, we leave the device up and the rules configured.
* We just call nmp_route_manager_sync() to forget about the synced rules, * We just call nmp_global_tracker_sync() to forget about the synced rules,
* but we don't actually delete them. * but we don't actually delete them.
* *
* FIXME: that is a problem after restart of NetworkManager, because these * FIXME: that is a problem after restart of NetworkManager, because these
@ -9577,7 +9577,7 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
* file and track them after restart again. */ * file and track them after restart again. */
keep_deleted_rules = TRUE; keep_deleted_rules = TRUE;
} }
nmp_route_manager_sync(route_manager, NMP_OBJECT_TYPE_ROUTING_RULE, keep_deleted_rules); nmp_global_tracker_sync(global_tracker, NMP_OBJECT_TYPE_ROUTING_RULE, keep_deleted_rules);
} }
static gboolean static gboolean

36
src/core/nm-l3cfg.c
View file

@ -3450,15 +3450,16 @@ nm_l3cfg_remove_config_all_dirty(NML3Cfg *self, gconstpointer tag)
/*****************************************************************************/ /*****************************************************************************/
#define _NODEV_ROUTES_TAG(self, IS_IPv4) ((gconstpointer) (&(&(self)->priv.route_manager)[IS_IPv4])) #define _NODEV_ROUTES_TAG(self, IS_IPv4) \
((gconstpointer) (&(&(self)->priv.global_tracker)[IS_IPv4]))
static gboolean static gboolean
_nodev_routes_untrack(NML3Cfg *self, int addr_family) _nodev_routes_untrack(NML3Cfg *self, int addr_family)
{ {
return nmp_route_manager_untrack_all(self->priv.route_manager, return nmp_global_tracker_untrack_all(self->priv.global_tracker,
_NODEV_ROUTES_TAG(self, NM_IS_IPv4(addr_family)), _NODEV_ROUTES_TAG(self, NM_IS_IPv4(addr_family)),
FALSE, FALSE,
TRUE); TRUE);
} }
static void static void
@ -3478,12 +3479,12 @@ _nodev_routes_sync(NML3Cfg *self,
for (i = 0; i < routes_nodev->len; i++) { for (i = 0; i < routes_nodev->len; i++) {
const NMPObject *obj = routes_nodev->pdata[i]; const NMPObject *obj = routes_nodev->pdata[i];
if (nmp_route_manager_track(self->priv.route_manager, if (nmp_global_tracker_track(self->priv.global_tracker,
obj_type, obj_type,
NMP_OBJECT_CAST_IP_ROUTE(obj), NMP_OBJECT_CAST_IP_ROUTE(obj),
1, 1,
_NODEV_ROUTES_TAG(self, IS_IPv4), _NODEV_ROUTES_TAG(self, IS_IPv4),
NULL)) NULL))
changed = TRUE; changed = TRUE;
} }
@ -3492,7 +3493,9 @@ out_clear:
changed = TRUE; changed = TRUE;
if (changed || commit_type >= NM_L3_CFG_COMMIT_TYPE_REAPPLY) if (changed || commit_type >= NM_L3_CFG_COMMIT_TYPE_REAPPLY)
nmp_route_manager_sync(self->priv.route_manager, NMP_OBJECT_TYPE_IP_ROUTE(IS_IPv4), FALSE); nmp_global_tracker_sync(self->priv.global_tracker,
NMP_OBJECT_TYPE_IP_ROUTE(IS_IPv4),
FALSE);
} }
/*****************************************************************************/ /*****************************************************************************/
@ -4764,7 +4767,8 @@ constructed(GObject *object)
self->priv.platform = g_object_ref(nm_netns_get_platform(self->priv.netns)); self->priv.platform = g_object_ref(nm_netns_get_platform(self->priv.netns));
nm_assert(NM_IS_PLATFORM(self->priv.platform)); nm_assert(NM_IS_PLATFORM(self->priv.platform));
self->priv.route_manager = nmp_route_manager_ref(nm_netns_get_route_manager(self->priv.netns)); self->priv.global_tracker =
nmp_global_tracker_ref(nm_netns_get_global_tracker(self->priv.netns));
_LOGT("created (netns=" NM_HASH_OBFUSCATE_PTR_FMT ")", NM_HASH_OBFUSCATE_PTR(self->priv.netns)); _LOGT("created (netns=" NM_HASH_OBFUSCATE_PTR_FMT ")", NM_HASH_OBFUSCATE_PTR(self->priv.netns));
@ -4819,13 +4823,13 @@ finalize(GObject *object)
nm_assert(c_list_is_empty(&self->priv.p->obj_state_zombie_lst_head)); nm_assert(c_list_is_empty(&self->priv.p->obj_state_zombie_lst_head));
if (_nodev_routes_untrack(self, AF_INET)) if (_nodev_routes_untrack(self, AF_INET))
nmp_route_manager_sync(self->priv.route_manager, NMP_OBJECT_TYPE_IP4_ROUTE, FALSE); nmp_global_tracker_sync(self->priv.global_tracker, NMP_OBJECT_TYPE_IP4_ROUTE, FALSE);
if (_nodev_routes_untrack(self, AF_INET6)) if (_nodev_routes_untrack(self, AF_INET6))
nmp_route_manager_sync(self->priv.route_manager, NMP_OBJECT_TYPE_IP6_ROUTE, FALSE); nmp_global_tracker_sync(self->priv.global_tracker, NMP_OBJECT_TYPE_IP6_ROUTE, FALSE);
g_clear_object(&self->priv.netns); g_clear_object(&self->priv.netns);
g_clear_object(&self->priv.platform); g_clear_object(&self->priv.platform);
nm_clear_pointer(&self->priv.route_manager, nmp_route_manager_unref); nm_clear_pointer(&self->priv.global_tracker, nmp_global_tracker_unref);
nm_clear_l3cd(&self->priv.p->combined_l3cd_merged); nm_clear_l3cd(&self->priv.p->combined_l3cd_merged);
nm_clear_l3cd(&self->priv.p->combined_l3cd_commited); nm_clear_l3cd(&self->priv.p->combined_l3cd_commited);

16
src/core/nm-l3cfg.h
View file

@ -196,18 +196,18 @@ typedef struct {
} NML3ConfigNotifyData; } NML3ConfigNotifyData;
struct _NML3CfgPrivate; struct _NML3CfgPrivate;
struct _NMPRouteManager; struct _NMPGlobalTracker;
struct _NML3Cfg { struct _NML3Cfg {
GObject parent; GObject parent;
struct { struct {
struct _NML3CfgPrivate *p; struct _NML3CfgPrivate *p;
NMNetns *netns; NMNetns *netns;
NMPlatform *platform; NMPlatform *platform;
struct _NMPRouteManager *route_manager; struct _NMPGlobalTracker *global_tracker;
const NMPObject *plobj; const NMPObject *plobj;
const NMPObject *plobj_next; const NMPObject *plobj_next;
int ifindex; int ifindex;
} priv; } priv;
}; };

46
src/core/nm-netns.c
View file

@ -22,14 +22,14 @@
NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_PLATFORM, ); NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_PLATFORM, );
typedef struct { typedef struct {
NMNetns *_self_signal_user_data; NMNetns *_self_signal_user_data;
NMPlatform *platform; NMPlatform *platform;
NMPNetns *platform_netns; NMPNetns *platform_netns;
NMPRouteManager *route_manager; NMPGlobalTracker *global_tracker;
GHashTable *l3cfgs; GHashTable *l3cfgs;
GHashTable *shared_ips; GHashTable *shared_ips;
CList l3cfg_signal_pending_lst_head; CList l3cfg_signal_pending_lst_head;
GSource *signal_pending_idle_source; GSource *signal_pending_idle_source;
} NMNetnsPrivate; } NMNetnsPrivate;
struct _NMNetns { struct _NMNetns {
@ -79,10 +79,10 @@ nm_netns_get_platform(NMNetns *self)
return NM_NETNS_GET_PRIVATE(self)->platform; return NM_NETNS_GET_PRIVATE(self)->platform;
} }
NMPRouteManager * NMPGlobalTracker *
nm_netns_get_route_manager(NMNetns *self) nm_netns_get_global_tracker(NMNetns *self)
{ {
return NM_NETNS_GET_PRIVATE(self)->route_manager; return NM_NETNS_GET_PRIVATE(self)->global_tracker;
} }
NMDedupMultiIndex * NMDedupMultiIndex *
@ -397,14 +397,14 @@ constructed(GObject *object)
priv->platform_netns = nm_platform_netns_get(priv->platform); priv->platform_netns = nm_platform_netns_get(priv->platform);
priv->route_manager = nmp_route_manager_new(priv->platform); priv->global_tracker = nmp_global_tracker_new(priv->platform);
/* Weakly track the default rules with a dummy user-tag. These /* Weakly track the default rules with a dummy user-tag. These
* rules are always weekly tracked... */ * rules are always weekly tracked... */
nmp_route_manager_track_rule_default(priv->route_manager, nmp_global_tracker_track_rule_default(priv->global_tracker,
AF_UNSPEC, AF_UNSPEC,
0, 0,
nm_netns_parent_class /* static dummy user-tag */); nm_netns_parent_class /* static dummy user-tag */);
/* Also weakly track all existing rules. These were added before NetworkManager /* Also weakly track all existing rules. These were added before NetworkManager
* starts, so they are probably none of NetworkManager's business. * starts, so they are probably none of NetworkManager's business.
@ -414,12 +414,12 @@ constructed(GObject *object)
* of NetworkManager, we just don't know. * of NetworkManager, we just don't know.
* *
* For that reason, whenever we will touch such rules later one, we make them * For that reason, whenever we will touch such rules later one, we make them
* fully owned and no longer weekly tracked. See %NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG. */ * fully owned and no longer weekly tracked. See %NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG. */
nmp_route_manager_track_rule_from_platform(priv->route_manager, nmp_global_tracker_track_rule_from_platform(priv->global_tracker,
NULL, NULL,
AF_UNSPEC, AF_UNSPEC,
0, 0,
NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG); NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG);
G_OBJECT_CLASS(nm_netns_parent_class)->constructed(object); G_OBJECT_CLASS(nm_netns_parent_class)->constructed(object);
@ -469,7 +469,7 @@ dispose(GObject *object)
g_clear_object(&priv->platform); g_clear_object(&priv->platform);
nm_clear_pointer(&priv->l3cfgs, g_hash_table_unref); nm_clear_pointer(&priv->l3cfgs, g_hash_table_unref);
nm_clear_pointer(&priv->route_manager, nmp_route_manager_unref); nm_clear_pointer(&priv->global_tracker, nmp_global_tracker_unref);
G_OBJECT_CLASS(nm_netns_parent_class)->dispose(object); G_OBJECT_CLASS(nm_netns_parent_class)->dispose(object);
} }

2
src/core/nm-netns.h
View file

@ -29,7 +29,7 @@ NMNetns *nm_netns_new(struct _NMPlatform *platform);
struct _NMPlatform *nm_netns_get_platform(NMNetns *self); struct _NMPlatform *nm_netns_get_platform(NMNetns *self);
NMPNetns *nm_netns_get_platform_netns(NMNetns *self); NMPNetns *nm_netns_get_platform_netns(NMNetns *self);
struct _NMPRouteManager *nm_netns_get_route_manager(NMNetns *self); struct _NMPGlobalTracker *nm_netns_get_global_tracker(NMNetns *self);
struct _NMDedupMultiIndex *nm_netns_get_multi_idx(NMNetns *self); struct _NMDedupMultiIndex *nm_netns_get_multi_idx(NMNetns *self);

64
src/core/platform/tests/test-route.c
View file

@ -1647,8 +1647,8 @@ again:
if (TEST_SYNC) { if (TEST_SYNC) {
gs_unref_hashtable GHashTable *unique_priorities = g_hash_table_new(NULL, NULL); gs_unref_hashtable GHashTable *unique_priorities = g_hash_table_new(NULL, NULL);
nm_auto_unref_route_manager NMPRouteManager *route_manager = nm_auto_unref_global_tracker NMPGlobalTracker *global_tracker =
nmp_route_manager_new(platform); nmp_global_tracker_new(platform);
gs_unref_ptrarray GPtrArray *objs_sync = NULL; gs_unref_ptrarray GPtrArray *objs_sync = NULL;
gconstpointer USER_TAG_1 = &platform; gconstpointer USER_TAG_1 = &platform;
gconstpointer USER_TAG_2 = &unique_priorities; gconstpointer USER_TAG_2 = &unique_priorities;
@ -1670,29 +1670,29 @@ again:
} }
for (i = 0; i < objs_sync->len; i++) { for (i = 0; i < objs_sync->len; i++) {
nmp_route_manager_track_rule(route_manager, nmp_global_tracker_track_rule(global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
1, 1,
USER_TAG_1, USER_TAG_1,
NULL); NULL);
if (nmtst_get_rand_bool()) { if (nmtst_get_rand_bool()) {
/* this has no effect, because a negative priority (of same absolute value) /* this has no effect, because a negative priority (of same absolute value)
* has lower priority than the positive priority above. */ * has lower priority than the positive priority above. */
nmp_route_manager_track_rule(route_manager, nmp_global_tracker_track_rule(global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-1, -1,
USER_TAG_2, USER_TAG_2,
NULL); NULL);
} }
if (nmtst_get_rand_uint32() % objs_sync->len == 0) { if (nmtst_get_rand_uint32() % objs_sync->len == 0) {
nmp_route_manager_sync(route_manager, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE); nmp_global_tracker_sync(global_tracker, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE);
g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC), g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC),
==, ==,
i + 1); i + 1);
} }
} }
nmp_route_manager_sync(route_manager, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE); nmp_global_tracker_sync(global_tracker, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE);
g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC), g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC),
==, ==,
objs_sync->len); objs_sync->len);
@ -1700,37 +1700,37 @@ again:
for (i = 0; i < objs_sync->len; i++) { for (i = 0; i < objs_sync->len; i++) {
switch (nmtst_get_rand_uint32() % 3) { switch (nmtst_get_rand_uint32() % 3) {
case 0: case 0:
nmp_route_manager_untrack_rule(route_manager, nmp_global_tracker_untrack_rule(global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
USER_TAG_1); USER_TAG_1);
nmp_route_manager_untrack_rule(route_manager, nmp_global_tracker_untrack_rule(global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
USER_TAG_1); USER_TAG_1);
break; break;
case 1: case 1:
nmp_route_manager_track_rule(route_manager, nmp_global_tracker_track_rule(global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-1, -1,
USER_TAG_1, USER_TAG_1,
NULL); NULL);
break; break;
case 2: case 2:
nmp_route_manager_track_rule(route_manager, nmp_global_tracker_track_rule(global_tracker,
NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]), NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-2, -2,
USER_TAG_2, USER_TAG_2,
NULL); NULL);
break; break;
} }
if (nmtst_get_rand_uint32() % objs_sync->len == 0) { if (nmtst_get_rand_uint32() % objs_sync->len == 0) {
nmp_route_manager_sync(route_manager, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE); nmp_global_tracker_sync(global_tracker, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE);
g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC), g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC),
==, ==,
objs_sync->len - i - 1); objs_sync->len - i - 1);
} }
} }
nmp_route_manager_sync(route_manager, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE); nmp_global_tracker_sync(global_tracker, NMP_OBJECT_TYPE_ROUTING_RULE, FALSE);
} else { } else {
for (i = 0; i < objs->len;) { for (i = 0; i < objs->len;) {

240
src/libnm-platform/nmp-route-manager.c
View file

@ -13,7 +13,7 @@
/*****************************************************************************/ /*****************************************************************************/
struct _NMPRouteManager { struct _NMPGlobalTracker {
NMPlatform *platform; NMPlatform *platform;
GHashTable *by_obj; GHashTable *by_obj;
GHashTable *by_user_tag; GHashTable *by_user_tag;
@ -25,17 +25,17 @@ struct _NMPRouteManager {
/*****************************************************************************/ /*****************************************************************************/
#define _NMLOG_DOMAIN LOGD_PLATFORM #define _NMLOG_DOMAIN LOGD_PLATFORM
#define _NMLOG_PREFIX_NAME "route-manager" #define _NMLOG_PREFIX_NAME "global-tracker"
#define _NMLOG(level, ...) __NMLOG_DEFAULT(level, LOGD_PLATFORM, _NMLOG_PREFIX_NAME, __VA_ARGS__) #define _NMLOG(level, ...) __NMLOG_DEFAULT(level, LOGD_PLATFORM, _NMLOG_PREFIX_NAME, __VA_ARGS__)
/*****************************************************************************/ /*****************************************************************************/
static gboolean static gboolean
NMP_IS_ROUTE_MANAGER(gpointer self) NMP_IS_GLOBAL_TRACKER(gpointer self)
{ {
return self && ((NMPRouteManager *) self)->ref_count > 0 return self && ((NMPGlobalTracker *) self)->ref_count > 0
&& NM_IS_PLATFORM(((NMPRouteManager *) self)->platform); && NM_IS_PLATFORM(((NMPGlobalTracker *) self)->platform);
} }
/*****************************************************************************/ /*****************************************************************************/
@ -91,13 +91,13 @@ typedef struct {
/* indicates whether we configured/removed the rule (during sync()). We need that, so /* indicates whether we configured/removed the rule (during sync()). We need that, so
* if the rule gets untracked, that we know to remove/restore it. * if the rule gets untracked, that we know to remove/restore it.
* *
* This makes NMPRouteManager stateful (beyond the configuration that indicates * This makes NMPGlobalTracker stateful (beyond the configuration that indicates
* which rules are tracked). * which rules are tracked).
* After a restart, NetworkManager would no longer remember which rules were added * After a restart, NetworkManager would no longer remember which rules were added
* by us. * by us.
* *
* That is partially fixed by NetworkManager taking over the rules that it * That is partially fixed by NetworkManager taking over the rules that it
* actively configures (see %NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG). */ * actively configures (see %NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG). */
ConfigState config_state; ConfigState config_state;
} TrackObjData; } TrackObjData;
@ -108,15 +108,15 @@ typedef struct {
/*****************************************************************************/ /*****************************************************************************/
static void _track_data_untrack(NMPRouteManager *self, static void _track_data_untrack(NMPGlobalTracker *self,
TrackData *track_data, TrackData *track_data,
gboolean remove_user_tag_data, gboolean remove_user_tag_data,
gboolean make_owned_by_us); gboolean make_owned_by_us);
/*****************************************************************************/ /*****************************************************************************/
static CList * static CList *
_by_obj_lst_head(NMPRouteManager *self, NMPObjectType obj_type) _by_obj_lst_head(NMPGlobalTracker *self, NMPObjectType obj_type)
{ {
G_STATIC_ASSERT(G_N_ELEMENTS(self->by_obj_lst_heads) == 3); G_STATIC_ASSERT(G_N_ELEMENTS(self->by_obj_lst_heads) == 3);
@ -266,8 +266,8 @@ _track_data_lookup(GHashTable *by_data, const NMPObject *obj, gconstpointer user
/*****************************************************************************/ /*****************************************************************************/
/** /**
* nmp_route_manager_track: * nmp_global_tracker_track:
* @self: the #NMPRouteManager instance * @self: the #NMPGlobalTracker instance
* @obj_type: the NMPObjectType of @obj that we are tracking. * @obj_type: the NMPObjectType of @obj that we are tracking.
* @obj: the NMPlatformObject (of type NMPObjectType) to track. Usually * @obj: the NMPlatformObject (of type NMPObjectType) to track. Usually
* a #NMPlatformRoutingRule, #NMPlatformIP4Route or #NMPlatformIP6Route * a #NMPlatformRoutingRule, #NMPlatformIP4Route or #NMPlatformIP6Route
@ -282,20 +282,20 @@ _track_data_lookup(GHashTable *by_data, const NMPObject *obj, gconstpointer user
* @user_tag: the tag associated with tracking this rule. The same tag * @user_tag: the tag associated with tracking this rule. The same tag
* must be used to untrack the rule later. * must be used to untrack the rule later.
* @user_tag_untrack: if not %NULL, at the same time untrack this user-tag * @user_tag_untrack: if not %NULL, at the same time untrack this user-tag
* for the same rule. Note that this is different from a plain nmp_route_manager_untrack_rule(), * for the same rule. Note that this is different from a plain nmp_global_tracker_untrack_rule(),
* because it enforces ownership of the now tracked rule. On the other hand, * because it enforces ownership of the now tracked rule. On the other hand,
* a plain nmp_route_manager_untrack_rule() merely forgets about the tracking. * a plain nmp_global_tracker_untrack_rule() merely forgets about the tracking.
* The purpose here is to set this to %NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG. * The purpose here is to set this to %NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG.
* *
* Returns: %TRUE, if something changed. * Returns: %TRUE, if something changed.
*/ */
gboolean gboolean
nmp_route_manager_track(NMPRouteManager *self, nmp_global_tracker_track(NMPGlobalTracker *self,
NMPObjectType obj_type, NMPObjectType obj_type,
gconstpointer obj, gconstpointer obj,
gint32 track_priority, gint32 track_priority,
gconstpointer user_tag, gconstpointer user_tag,
gconstpointer user_tag_untrack) gconstpointer user_tag_untrack)
{ {
NMPObject obj_stack; NMPObject obj_stack;
const NMPObject *p_obj_stack; const NMPObject *p_obj_stack;
@ -307,7 +307,7 @@ nmp_route_manager_track(NMPRouteManager *self,
guint32 track_priority_val; guint32 track_priority_val;
gboolean track_priority_present; gboolean track_priority_present;
g_return_val_if_fail(NMP_IS_ROUTE_MANAGER(self), FALSE); g_return_val_if_fail(NMP_IS_GLOBAL_TRACKER(self), FALSE);
g_return_val_if_fail(obj, FALSE); g_return_val_if_fail(obj, FALSE);
g_return_val_if_fail(user_tag, FALSE); g_return_val_if_fail(user_tag, FALSE);
@ -414,15 +414,15 @@ nmp_route_manager_track(NMPRouteManager *self,
} }
static void static void
_track_data_untrack(NMPRouteManager *self, _track_data_untrack(NMPGlobalTracker *self,
TrackData *track_data, TrackData *track_data,
gboolean remove_user_tag_data, gboolean remove_user_tag_data,
gboolean make_owned_by_us) gboolean make_owned_by_us)
{ {
char sbuf[NM_UTILS_TO_STRING_BUFFER_SIZE]; char sbuf[NM_UTILS_TO_STRING_BUFFER_SIZE];
TrackObjData *obj_data; TrackObjData *obj_data;
nm_assert(NMP_IS_ROUTE_MANAGER(self)); nm_assert(NMP_IS_GLOBAL_TRACKER(self));
_track_data_assert(track_data, TRUE); _track_data_assert(track_data, TRUE);
nm_assert(self->by_data); nm_assert(self->by_data);
nm_assert(g_hash_table_lookup(self->by_data, track_data) == track_data); nm_assert(g_hash_table_lookup(self->by_data, track_data) == track_data);
@ -467,17 +467,17 @@ _track_data_untrack(NMPRouteManager *self,
} }
gboolean gboolean
nmp_route_manager_untrack(NMPRouteManager *self, nmp_global_tracker_untrack(NMPGlobalTracker *self,
NMPObjectType obj_type, NMPObjectType obj_type,
gconstpointer obj, gconstpointer obj,
gconstpointer user_tag) gconstpointer user_tag)
{ {
NMPObject obj_stack; NMPObject obj_stack;
const NMPObject *p_obj_stack; const NMPObject *p_obj_stack;
TrackData *track_data; TrackData *track_data;
gboolean changed = FALSE; gboolean changed = FALSE;
g_return_val_if_fail(NMP_IS_ROUTE_MANAGER(self), FALSE); g_return_val_if_fail(NMP_IS_GLOBAL_TRACKER(self), FALSE);
nm_assert(NM_IN_SET(obj_type, nm_assert(NM_IN_SET(obj_type,
NMP_OBJECT_TYPE_IP4_ROUTE, NMP_OBJECT_TYPE_IP4_ROUTE,
NMP_OBJECT_TYPE_IP6_ROUTE, NMP_OBJECT_TYPE_IP6_ROUTE,
@ -499,12 +499,12 @@ nmp_route_manager_untrack(NMPRouteManager *self,
} }
void void
nmp_route_manager_set_dirty(NMPRouteManager *self, gconstpointer user_tag) nmp_global_tracker_set_dirty(NMPGlobalTracker *self, gconstpointer user_tag)
{ {
TrackData *track_data; TrackData *track_data;
TrackUserTagData *user_tag_data; TrackUserTagData *user_tag_data;
g_return_if_fail(NMP_IS_ROUTE_MANAGER(self)); g_return_if_fail(NMP_IS_GLOBAL_TRACKER(self));
g_return_if_fail(user_tag); g_return_if_fail(user_tag);
user_tag_data = g_hash_table_lookup(self->by_user_tag, &user_tag); user_tag_data = g_hash_table_lookup(self->by_user_tag, &user_tag);
@ -516,17 +516,17 @@ nmp_route_manager_set_dirty(NMPRouteManager *self, gconstpointer user_tag)
} }
gboolean gboolean
nmp_route_manager_untrack_all(NMPRouteManager *self, nmp_global_tracker_untrack_all(NMPGlobalTracker *self,
gconstpointer user_tag, gconstpointer user_tag,
gboolean all /* or only dirty */, gboolean all /* or only dirty */,
gboolean make_survivors_dirty) gboolean make_survivors_dirty)
{ {
TrackData *track_data; TrackData *track_data;
TrackData *track_data_safe; TrackData *track_data_safe;
TrackUserTagData *user_tag_data; TrackUserTagData *user_tag_data;
gboolean changed = FALSE; gboolean changed = FALSE;
g_return_val_if_fail(NMP_IS_ROUTE_MANAGER(self), FALSE); g_return_val_if_fail(NMP_IS_GLOBAL_TRACKER(self), FALSE);
g_return_val_if_fail(user_tag, FALSE); g_return_val_if_fail(user_tag, FALSE);
user_tag_data = g_hash_table_lookup(self->by_user_tag, &user_tag); user_tag_data = g_hash_table_lookup(self->by_user_tag, &user_tag);
@ -554,7 +554,7 @@ nmp_route_manager_untrack_all(NMPRouteManager *self,
/*****************************************************************************/ /*****************************************************************************/
void void
nmp_route_manager_sync(NMPRouteManager *self, NMPObjectType obj_type, gboolean keep_deleted) nmp_global_tracker_sync(NMPGlobalTracker *self, NMPObjectType obj_type, gboolean keep_deleted)
{ {
char sbuf[NM_UTILS_TO_STRING_BUFFER_SIZE]; char sbuf[NM_UTILS_TO_STRING_BUFFER_SIZE];
const NMDedupMultiHeadEntry *pl_head_entry; const NMDedupMultiHeadEntry *pl_head_entry;
@ -567,7 +567,7 @@ nmp_route_manager_sync(NMPRouteManager *self, NMPObjectType obj_type, gboolean k
guint i; guint i;
const TrackData *td_best; const TrackData *td_best;
g_return_if_fail(NMP_IS_ROUTE_MANAGER(self)); g_return_if_fail(NMP_IS_GLOBAL_TRACKER(self));
g_return_if_fail(NM_IN_SET(obj_type, g_return_if_fail(NM_IN_SET(obj_type,
NMP_OBJECT_TYPE_IP4_ROUTE, NMP_OBJECT_TYPE_IP4_ROUTE,
NMP_OBJECT_TYPE_IP6_ROUTE, NMP_OBJECT_TYPE_IP6_ROUTE,
@ -677,18 +677,18 @@ nmp_route_manager_sync(NMPRouteManager *self, NMPObjectType obj_type, gboolean k
/*****************************************************************************/ /*****************************************************************************/
void void
nmp_route_manager_track_rule_from_platform(NMPRouteManager *self, nmp_global_tracker_track_rule_from_platform(NMPGlobalTracker *self,
NMPlatform *platform, NMPlatform *platform,
int addr_family, int addr_family,
gint32 tracking_priority, gint32 tracking_priority,
gconstpointer user_tag) gconstpointer user_tag)
{ {
NMPLookup lookup; NMPLookup lookup;
const NMDedupMultiHeadEntry *head_entry; const NMDedupMultiHeadEntry *head_entry;
NMDedupMultiIter iter; NMDedupMultiIter iter;
const NMPObject *o; const NMPObject *o;
g_return_if_fail(NMP_IS_ROUTE_MANAGER(self)); g_return_if_fail(NMP_IS_GLOBAL_TRACKER(self));
if (!platform) if (!platform)
platform = self->platform; platform = self->platform;
@ -705,98 +705,98 @@ nmp_route_manager_track_rule_from_platform(NMPRouteManager *self,
if (addr_family != AF_UNSPEC && rr->addr_family != addr_family) if (addr_family != AF_UNSPEC && rr->addr_family != addr_family)
continue; continue;
nmp_route_manager_track_rule(self, rr, tracking_priority, user_tag, NULL); nmp_global_tracker_track_rule(self, rr, tracking_priority, user_tag, NULL);
} }
} }
/*****************************************************************************/ /*****************************************************************************/
void void
nmp_route_manager_track_rule_default(NMPRouteManager *self, nmp_global_tracker_track_rule_default(NMPGlobalTracker *self,
int addr_family, int addr_family,
gint32 track_priority, gint32 track_priority,
gconstpointer user_tag) gconstpointer user_tag)
{ {
g_return_if_fail(NMP_IS_ROUTE_MANAGER(self)); g_return_if_fail(NMP_IS_GLOBAL_TRACKER(self));
nm_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6)); nm_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6));
/* track the default rules. See also `man ip-rule`. */ /* track the default rules. See also `man ip-rule`. */
if (NM_IN_SET(addr_family, AF_UNSPEC, AF_INET)) { if (NM_IN_SET(addr_family, AF_UNSPEC, AF_INET)) {
nmp_route_manager_track_rule(self, nmp_global_tracker_track_rule(self,
&((NMPlatformRoutingRule){ &((NMPlatformRoutingRule){
.addr_family = AF_INET, .addr_family = AF_INET,
.priority = 0, .priority = 0,
.table = RT_TABLE_LOCAL, .table = RT_TABLE_LOCAL,
.action = FR_ACT_TO_TBL, .action = FR_ACT_TO_TBL,
.protocol = RTPROT_KERNEL, .protocol = RTPROT_KERNEL,
}), }),
track_priority, track_priority,
user_tag, user_tag,
NULL); NULL);
nmp_route_manager_track_rule(self, nmp_global_tracker_track_rule(self,
&((NMPlatformRoutingRule){ &((NMPlatformRoutingRule){
.addr_family = AF_INET, .addr_family = AF_INET,
.priority = 32766, .priority = 32766,
.table = RT_TABLE_MAIN, .table = RT_TABLE_MAIN,
.action = FR_ACT_TO_TBL, .action = FR_ACT_TO_TBL,
.protocol = RTPROT_KERNEL, .protocol = RTPROT_KERNEL,
}), }),
track_priority, track_priority,
user_tag, user_tag,
NULL); NULL);
nmp_route_manager_track_rule(self, nmp_global_tracker_track_rule(self,
&((NMPlatformRoutingRule){ &((NMPlatformRoutingRule){
.addr_family = AF_INET, .addr_family = AF_INET,
.priority = 32767, .priority = 32767,
.table = RT_TABLE_DEFAULT, .table = RT_TABLE_DEFAULT,
.action = FR_ACT_TO_TBL, .action = FR_ACT_TO_TBL,
.protocol = RTPROT_KERNEL, .protocol = RTPROT_KERNEL,
}), }),
track_priority, track_priority,
user_tag, user_tag,
NULL); NULL);
} }
if (NM_IN_SET(addr_family, AF_UNSPEC, AF_INET6)) { if (NM_IN_SET(addr_family, AF_UNSPEC, AF_INET6)) {
nmp_route_manager_track_rule(self, nmp_global_tracker_track_rule(self,
&((NMPlatformRoutingRule){ &((NMPlatformRoutingRule){
.addr_family = AF_INET6, .addr_family = AF_INET6,
.priority = 0, .priority = 0,
.table = RT_TABLE_LOCAL, .table = RT_TABLE_LOCAL,
.action = FR_ACT_TO_TBL, .action = FR_ACT_TO_TBL,
.protocol = RTPROT_KERNEL, .protocol = RTPROT_KERNEL,
}), }),
track_priority, track_priority,
user_tag, user_tag,
NULL); NULL);
nmp_route_manager_track_rule(self, nmp_global_tracker_track_rule(self,
&((NMPlatformRoutingRule){ &((NMPlatformRoutingRule){
.addr_family = AF_INET6, .addr_family = AF_INET6,
.priority = 32766, .priority = 32766,
.table = RT_TABLE_MAIN, .table = RT_TABLE_MAIN,
.action = FR_ACT_TO_TBL, .action = FR_ACT_TO_TBL,
.protocol = RTPROT_KERNEL, .protocol = RTPROT_KERNEL,
}), }),
track_priority, track_priority,
user_tag, user_tag,
NULL); NULL);
} }
} }
/*****************************************************************************/ /*****************************************************************************/
NMPRouteManager * NMPGlobalTracker *
nmp_route_manager_new(NMPlatform *platform) nmp_global_tracker_new(NMPlatform *platform)
{ {
NMPRouteManager *self; NMPGlobalTracker *self;
g_return_val_if_fail(NM_IS_PLATFORM(platform), NULL); g_return_val_if_fail(NM_IS_PLATFORM(platform), NULL);
G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(TrackUserTagData, user_tag) == 0); G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(TrackUserTagData, user_tag) == 0);
self = g_slice_new(NMPRouteManager); self = g_slice_new(NMPGlobalTracker);
*self = (NMPRouteManager){ *self = (NMPGlobalTracker){
.ref_count = 1, .ref_count = 1,
.platform = g_object_ref(platform), .platform = g_object_ref(platform),
.by_data = .by_data =
@ -816,19 +816,19 @@ nmp_route_manager_new(NMPlatform *platform)
return self; return self;
} }
NMPRouteManager * NMPGlobalTracker *
nmp_route_manager_ref(NMPRouteManager *self) nmp_global_tracker_ref(NMPGlobalTracker *self)
{ {
g_return_val_if_fail(NMP_IS_ROUTE_MANAGER(self), NULL); g_return_val_if_fail(NMP_IS_GLOBAL_TRACKER(self), NULL);
self->ref_count++; self->ref_count++;
return self; return self;
} }
void void
nmp_route_manager_unref(NMPRouteManager *self) nmp_global_tracker_unref(NMPGlobalTracker *self)
{ {
g_return_if_fail(NMP_IS_ROUTE_MANAGER(self)); g_return_if_fail(NMP_IS_GLOBAL_TRACKER(self));
if (--self->ref_count > 0) if (--self->ref_count > 0)
return; return;

100
src/libnm-platform/nmp-route-manager.h
View file

@ -1,79 +1,79 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* SPDX-License-Identifier: LGPL-2.1-or-later */
#ifndef __NMP_ROUTE_MANAGER_H__ #ifndef __NMP_GLOBAL_TRACKER_H__
#define __NMP_ROUTE_MANAGER_H__ #define __NMP_GLOBAL_TRACKER_H__
#include "nm-platform.h" #include "nm-platform.h"
/*****************************************************************************/ /*****************************************************************************/
#define NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG ((const void *) nmp_route_manager_new) #define NMP_GLOBAL_TRACKER_EXTERN_WEAKLY_TRACKED_USER_TAG ((const void *) nmp_global_tracker_new)
typedef struct _NMPRouteManager NMPRouteManager; typedef struct _NMPGlobalTracker NMPGlobalTracker;
NMPRouteManager *nmp_route_manager_new(NMPlatform *platform); NMPGlobalTracker *nmp_global_tracker_new(NMPlatform *platform);
NMPRouteManager *nmp_route_manager_ref(NMPRouteManager *self); NMPGlobalTracker *nmp_global_tracker_ref(NMPGlobalTracker *self);
void nmp_route_manager_unref(NMPRouteManager *self); void nmp_global_tracker_unref(NMPGlobalTracker *self);
#define nm_auto_unref_route_manager nm_auto(_nmp_route_manager_unref) #define nm_auto_unref_global_tracker nm_auto(_nmp_global_tracker_unref)
NM_AUTO_DEFINE_FCN0(NMPRouteManager *, _nmp_route_manager_unref, nmp_route_manager_unref); NM_AUTO_DEFINE_FCN0(NMPGlobalTracker *, _nmp_global_tracker_unref, nmp_global_tracker_unref);
gboolean nmp_route_manager_track(NMPRouteManager *self, gboolean nmp_global_tracker_track(NMPGlobalTracker *self,
NMPObjectType obj_type, NMPObjectType obj_type,
gconstpointer obj, gconstpointer obj,
gint32 track_priority, gint32 track_priority,
gconstpointer user_tag, gconstpointer user_tag,
gconstpointer user_tag_untrack); gconstpointer user_tag_untrack);
static inline gboolean static inline gboolean
nmp_route_manager_track_rule(NMPRouteManager *self, nmp_global_tracker_track_rule(NMPGlobalTracker *self,
const NMPlatformRoutingRule *routing_rule, const NMPlatformRoutingRule *routing_rule,
gint32 track_priority, gint32 track_priority,
gconstpointer user_tag, gconstpointer user_tag,
gconstpointer user_tag_untrack) gconstpointer user_tag_untrack)
{ {
return nmp_route_manager_track(self, return nmp_global_tracker_track(self,
NMP_OBJECT_TYPE_ROUTING_RULE, NMP_OBJECT_TYPE_ROUTING_RULE,
routing_rule, routing_rule,
track_priority, track_priority,
user_tag, user_tag,
user_tag_untrack); user_tag_untrack);
} }
void nmp_route_manager_track_rule_default(NMPRouteManager *self, void nmp_global_tracker_track_rule_default(NMPGlobalTracker *self,
int addr_family, int addr_family,
gint32 track_priority, gint32 track_priority,
gconstpointer user_tag); gconstpointer user_tag);
void nmp_route_manager_track_rule_from_platform(NMPRouteManager *self, void nmp_global_tracker_track_rule_from_platform(NMPGlobalTracker *self,
NMPlatform *platform, NMPlatform *platform,
int addr_family, int addr_family,
gint32 tracking_priority, gint32 tracking_priority,
gconstpointer user_tag); gconstpointer user_tag);
gboolean nmp_route_manager_untrack(NMPRouteManager *self, gboolean nmp_global_tracker_untrack(NMPGlobalTracker *self,
NMPObjectType obj_type, NMPObjectType obj_type,
gconstpointer obj, gconstpointer obj,
gconstpointer user_tag); gconstpointer user_tag);
static inline gboolean static inline gboolean
nmp_route_manager_untrack_rule(NMPRouteManager *self, nmp_global_tracker_untrack_rule(NMPGlobalTracker *self,
const NMPlatformRoutingRule *routing_rule, const NMPlatformRoutingRule *routing_rule,
gconstpointer user_tag) gconstpointer user_tag)
{ {
return nmp_route_manager_untrack(self, NMP_OBJECT_TYPE_ROUTING_RULE, routing_rule, user_tag); return nmp_global_tracker_untrack(self, NMP_OBJECT_TYPE_ROUTING_RULE, routing_rule, user_tag);
} }
void nmp_route_manager_set_dirty(NMPRouteManager *self, gconstpointer user_tag); void nmp_global_tracker_set_dirty(NMPGlobalTracker *self, gconstpointer user_tag);
gboolean nmp_route_manager_untrack_all(NMPRouteManager *self, gboolean nmp_global_tracker_untrack_all(NMPGlobalTracker *self,
gconstpointer user_tag, gconstpointer user_tag,
gboolean all /* or only dirty */, gboolean all /* or only dirty */,
gboolean make_survivors_dirty); gboolean make_survivors_dirty);
void nmp_route_manager_sync(NMPRouteManager *self, NMPObjectType obj_type, gboolean keep_deleted); void nmp_global_tracker_sync(NMPGlobalTracker *self, NMPObjectType obj_type, gboolean keep_deleted);
/*****************************************************************************/ /*****************************************************************************/
#endif /* __NMP_ROUTE_MANAGER_H__ */ #endif /* __NMP_GLOBAL_TRACKER_H__ */