core: replace 'whitelist' with 'allowlist' and 'blacklist' with 'blocklist'

We keep the 'WHITELIST-ONLY' filter type name still as an option in
--filter-policy=[POLICY], but deprecated and with the better
'ALLOWLIST-ONLY' replacement suggested from now on.

8 files changed, 101 insertions, 97 deletions

diff --git a/docs/man/ModemManager.8 b/docs/man/ModemManager.8
index 62a4e43f..55f09f48 100644
--- a/docs/man/ModemManager.8
+++ b/docs/man/ModemManager.8
@@ -25,8 +25,8 @@ from the command line.
 Specify which ports are probed and how:
 .RS 9
 .TP
-\fB'WHITELIST-ONLY'\fR
-Only devices or ports explicitly whitelisted with the 'ID_MM_DEVICE_PROCESS' udev tag are probed.
+\fB'ALLOWLIST-ONLY'\fR
+Only devices or ports explicitly allowlisted with the 'ID_MM_DEVICE_PROCESS' udev tag are probed.
 .TP
 \fB'STRICT'\fR
 Only the TTY ports that are heuristically determined to be very likely to be modem ports are probed. Nay end up ignoring some devices.
diff --git a/docs/reference/api/ModemManager-overview.xml b/docs/reference/api/ModemManager-overview.xml
index ff532fe4..12e1adc8 100644
--- a/docs/reference/api/ModemManager-overview.xml
+++ b/docs/reference/api/ModemManager-overview.xml
@@ -107,7 +107,7 @@
         predefined filter policies are based on one or more of these predefined filter rules.
         <itemizedlist>
           <listitem>
-            <para><emphasis>MM_FILTER_RULE_EXPLICIT_WHITELIST</emphasis></para>
+            <para><emphasis>MM_FILTER_RULE_EXPLICIT_ALLOWLIST</emphasis></para>
             <para>
               This filter allows users to manually tag devices and/or device ports with the
               <emphasis>ID_MM_DEVICE_PROCESS</emphasis> udev tag. If the filter finds this tag,
@@ -115,10 +115,10 @@
               will be allowed.
             </para>
             <programlisting>
-$ sudo vim /lib/udev/rules.d/78-mm-whitelist-internal-modem.rules
-    ACTION!="add|change|move", GOTO="mm_whitelist_internal_modem_end"
+$ sudo vim /lib/udev/rules.d/78-mm-allowlist-internal-modem.rules
+    ACTION!="add|change|move", GOTO="mm_allowlist_internal_modem_end"
     ATTRS{idVendor}=="1199", ATTRS{idProduct}=="a001", ENV{ID_MM_DEVICE_PROCESS}="1"
-    LABEL="mm_whitelist_internal_modem_end"
+    LABEL="mm_allowlist_internal_modem_end"
 // Apply new rules without reboot
 $ sudo udevadm control --reload
 $ sudo udevadm trigger
@@ -143,10 +143,10 @@ $ sudo udevadm trigger
             </programlisting>
           </listitem>
           <listitem>
-            <para><emphasis>MM_FILTER_RULE_PLUGIN_WHITELIST</emphasis></para>
+            <para><emphasis>MM_FILTER_RULE_PLUGIN_ALLOWLIST</emphasis></para>
             <para>
-              This filter will automatically whitelist devices that are explicitly referenced
-              by plugins, either with plugin-specific whitelist tags, with exact
+              This filter will automatically allowlist devices that are explicitly referenced
+              by plugins, either with plugin-specific allowlist tags, with exact
               <emphasis>vid:pid</emphasis> matches, or just with <emphasis>vid</emphasis> matches.
             </para>
           </listitem>
@@ -279,20 +279,20 @@ $ sudo udevadm trigger
         The predefined filter policies are:
         <itemizedlist>
           <listitem>
-            <para><emphasis>Whitelist only</emphasis></para>
+            <para><emphasis>Allowlist only</emphasis></para>
             <para>
-              This is a policy where only the MM_FILTER_RULE_EXPLICIT_WHITELIST rule is enabled.
+              This is a policy where only the MM_FILTER_RULE_EXPLICIT_ALLOWLIST rule is enabled.
             </para>
-            <programlisting># /usr/sbin/ModemManager --filter-policy=WHITELIST-ONLY</programlisting>
+            <programlisting># /usr/sbin/ModemManager --filter-policy=ALLOWLIST-ONLY</programlisting>
           </listitem>
           <listitem>
             <para><emphasis>Strict</emphasis></para>
             <para>
               This is a policy where the following rules are enabled:
               <itemizedlist>
-                <listitem>MM_FILTER_RULE_EXPLICIT_WHITELIST</listitem>
-                <listitem>MM_FILTER_RULE_EXPLICIT_BLACKLIST</listitem>
-                <listitem>MM_FILTER_RULE_PLUGIN_WHITELIST</listitem>
+                <listitem>MM_FILTER_RULE_EXPLICIT_ALLOWLIST</listitem>
+                <listitem>MM_FILTER_RULE_EXPLICIT_BLOCKLIST</listitem>
+                <listitem>MM_FILTER_RULE_PLUGIN_ALLOWLIST</listitem>
                 <listitem>MM_FILTER_RULE_QRTR</listitem>
                 <listitem>MM_FILTER_RULE_VIRTUAL</listitem>
                 <listitem>MM_FILTER_RULE_NET</listitem>
@@ -329,13 +329,13 @@ $ sudo udevadm trigger
   /usr/sbin/ModemManager --filter-policy=STRICT</programlisting>
             </para>
             <para>
-              E.g. this would launch ModemManager with the Whitelist-only filter policy but also
+              E.g. this would launch ModemManager with the allowlist-only filter policy but also
               explicitly allowing all net and cdc-wdm ports. Note that in this case, all virtual
               net ports (e.g. 'lo') are also being allowed.
               <programlisting>
 # MM_FILTER_RULE_NET=1 \
   MM_FILTER_RULE_USBMISC=1 \
-  /usr/sbin/ModemManager --filter-policy=WHITELIST-ONLY</programlisting>
+  /usr/sbin/ModemManager --filter-policy=ALLOWLIST-ONLY</programlisting>
             </para>
           </listitem>
         </itemizedlist>
diff --git a/include/ModemManager-tags.h b/include/ModemManager-tags.h
index decb4527..8eb8324f 100644
--- a/include/ModemManager-tags.h
+++ b/include/ModemManager-tags.h
@@ -68,8 +68,8 @@
  *
  * This is a device-specific tag that allows explicitly requesting the
  * processing of all ports exposed by the device. This tag is usually
- * used by users when the daemon runs with WHITELIST-ONLY filter policy
- * type, and is associated to the MM_FILTER_RULE_EXPLICIT_WHITELIST rule.
+ * used by users when the daemon runs with ALLOWLIST-ONLY filter policy
+ * type, and is associated to the MM_FILTER_RULE_EXPLICIT_ALLOWLIST rule.
  *
  * This tag may also be specified in specific ports, e.g. when the modem
  * exposes a single platform port without any parent device.
@@ -87,7 +87,7 @@
  * This tag was originally applicable to TTY ports and only when running
  * in certain filter policy types. Since 1.12, this tag applies to all
  * filter types and to all port types (not only TTYs), and is associated
- * to the MM_FILTER_RULE_EXPLICIT_BLACKLIST rule.
+ * to the MM_FILTER_RULE_EXPLICIT_BLOCKLIST rule.
  *
  * Since: 1.10
  */
diff --git a/plugins/sierra/mm-common-sierra.c b/plugins/sierra/mm-common-sierra.c
index f366050b..341006d6 100644
--- a/plugins/sierra/mm-common-sierra.c
+++ b/plugins/sierra/mm-common-sierra.c
@@ -144,13 +144,13 @@ gcap_ready (MMPortSerialAt *port,
     /* Sierra APPx ports have limited AT command parsers that just reply with
      * "OK" to most commands.  These can sometimes be used for PPP while the
      * main port is used for status and control, but older modems tend to crash
-     * or fail PPP.  So we whitelist modems that are known to allow PPP on the
+     * or fail PPP.  So we allowlist modems that are known to allow PPP on the
      * secondary APP ports.
      */
     if (strstr (response, "APP1")) {
         g_object_set_data (G_OBJECT (probe), TAG_SIERRA_APP_PORT, GUINT_TO_POINTER (TRUE));
 
-        /* PPP-on-APP1-port whitelist */
+        /* PPP-on-APP1-port allowlist */
         if (strstr (response, "C885") ||
             strstr (response, "USB 306") ||
             strstr (response, "MC8790"))
diff --git a/src/mm-context.c b/src/mm-context.c
index 8c341667..e86c57da 100644
--- a/src/mm-context.c
+++ b/src/mm-context.c
@@ -48,8 +48,12 @@ filter_policy_option_arg (const gchar  *option_name,
                           gpointer      data,
                           GError      **error)
 {
-    if (!g_ascii_strcasecmp (value, "whitelist-only")) {
-        filter_policy = MM_FILTER_POLICY_WHITELIST_ONLY;
+    if (!g_ascii_strcasecmp (value, "allowlist-only")
+#ifndef MM_DISABLE_DEPRECATED
+        || !g_ascii_strcasecmp (value, "whitelist-only")
+#endif
+        ) {
+        filter_policy = MM_FILTER_POLICY_ALLOWLIST_ONLY;
         return TRUE;
     }
 
@@ -67,7 +71,7 @@ filter_policy_option_arg (const gchar  *option_name,
 static const GOptionEntry entries[] = {
     {
         "filter-policy", 0, 0, G_OPTION_ARG_CALLBACK, filter_policy_option_arg,
-        "Filter policy: one of WHITELIST-ONLY, STRICT",
+        "Filter policy: one of ALLOWLIST-ONLY, STRICT",
         "[POLICY]"
     },
     {
diff --git a/src/mm-filter.c b/src/mm-filter.c
index b7a9d2f8..90d9b68d 100644
--- a/src/mm-filter.c
+++ b/src/mm-filter.c
@@ -38,67 +38,67 @@ enum {
 
 struct _MMFilterPrivate {
     MMFilterRule  enabled_rules;
-    GList        *plugin_whitelist_tags;
-    GArray       *plugin_whitelist_vendor_ids;
-    GArray       *plugin_whitelist_product_ids;
+    GList        *plugin_allowlist_tags;
+    GArray       *plugin_allowlist_vendor_ids;
+    GArray       *plugin_allowlist_product_ids;
 };
 
 /*****************************************************************************/
 
 void
-mm_filter_register_plugin_whitelist_tag (MMFilter    *self,
+mm_filter_register_plugin_allowlist_tag (MMFilter    *self,
                                          const gchar *tag)
 {
-    if (!g_list_find_custom (self->priv->plugin_whitelist_tags, tag, (GCompareFunc) g_strcmp0)) {
-        mm_obj_dbg (self, "registered plugin whitelist tag: %s", tag);
-        self->priv->plugin_whitelist_tags = g_list_prepend (self->priv->plugin_whitelist_tags, g_strdup (tag));
+    if (!g_list_find_custom (self->priv->plugin_allowlist_tags, tag, (GCompareFunc) g_strcmp0)) {
+        mm_obj_dbg (self, "registered plugin allowlist tag: %s", tag);
+        self->priv->plugin_allowlist_tags = g_list_prepend (self->priv->plugin_allowlist_tags, g_strdup (tag));
     }
 }
 
 void
-mm_filter_register_plugin_whitelist_vendor_id (MMFilter *self,
+mm_filter_register_plugin_allowlist_vendor_id (MMFilter *self,
                                                guint16   vid)
 {
     guint i;
 
-    if (!self->priv->plugin_whitelist_vendor_ids)
-        self->priv->plugin_whitelist_vendor_ids = g_array_sized_new (FALSE, FALSE, sizeof (guint16), 64);
+    if (!self->priv->plugin_allowlist_vendor_ids)
+        self->priv->plugin_allowlist_vendor_ids = g_array_sized_new (FALSE, FALSE, sizeof (guint16), 64);
 
-    for (i = 0; i < self->priv->plugin_whitelist_vendor_ids->len; i++) {
+    for (i = 0; i < self->priv->plugin_allowlist_vendor_ids->len; i++) {
         guint16 item;
 
-        item = g_array_index (self->priv->plugin_whitelist_vendor_ids, guint16, i);
+        item = g_array_index (self->priv->plugin_allowlist_vendor_ids, guint16, i);
         if (item == vid)
             return;
     }
 
-    g_array_append_val (self->priv->plugin_whitelist_vendor_ids, vid);
-    mm_obj_dbg (self, "registered plugin whitelist vendor id: %04x", vid);
+    g_array_append_val (self->priv->plugin_allowlist_vendor_ids, vid);
+    mm_obj_dbg (self, "registered plugin allowlist vendor id: %04x", vid);
 }
 
 void
-mm_filter_register_plugin_whitelist_product_id (MMFilter *self,
+mm_filter_register_plugin_allowlist_product_id (MMFilter *self,
                                                 guint16   vid,
                                                 guint16   pid)
 {
     mm_uint16_pair new_item;
     guint          i;
 
-    if (!self->priv->plugin_whitelist_product_ids)
-        self->priv->plugin_whitelist_product_ids = g_array_sized_new (FALSE, FALSE, sizeof (mm_uint16_pair), 10);
+    if (!self->priv->plugin_allowlist_product_ids)
+        self->priv->plugin_allowlist_product_ids = g_array_sized_new (FALSE, FALSE, sizeof (mm_uint16_pair), 10);
 
-    for (i = 0; i < self->priv->plugin_whitelist_product_ids->len; i++) {
+    for (i = 0; i < self->priv->plugin_allowlist_product_ids->len; i++) {
         mm_uint16_pair *item;
 
-        item = &g_array_index (self->priv->plugin_whitelist_product_ids, mm_uint16_pair, i);
+        item = &g_array_index (self->priv->plugin_allowlist_product_ids, mm_uint16_pair, i);
         if (item->l == vid && item->r == pid)
             return;
     }
 
     new_item.l = vid;
     new_item.r = pid;
-    g_array_append_val (self->priv->plugin_whitelist_product_ids, new_item);
-    mm_obj_dbg (self, "registered plugin whitelist product id: %04x:%04x", vid, pid);
+    g_array_append_val (self->priv->plugin_allowlist_product_ids, new_item);
+    mm_obj_dbg (self, "registered plugin allowlist product id: %04x:%04x", vid, pid);
 }
 
 /*****************************************************************************/
@@ -114,33 +114,33 @@ mm_filter_port (MMFilter        *self,
     subsystem = mm_kernel_device_get_subsystem (port);
     name      = mm_kernel_device_get_name      (port);
 
-    /* If the device is explicitly whitelisted, we process every port. Also
+    /* If the device is explicitly allowlisted, we process every port. Also
      * allow specifying this flag per-port instead of for the full device, e.g.
      * for platform tty ports where there's only one port anyway. */
-    if ((self->priv->enabled_rules & MM_FILTER_RULE_EXPLICIT_WHITELIST) &&
+    if ((self->priv->enabled_rules & MM_FILTER_RULE_EXPLICIT_ALLOWLIST) &&
         (mm_kernel_device_get_global_property_as_boolean (port, ID_MM_DEVICE_PROCESS) ||
          mm_kernel_device_get_property_as_boolean (port, ID_MM_DEVICE_PROCESS))) {
-        mm_obj_dbg (self, "(%s/%s) port allowed: device is whitelisted", subsystem, name);
+        mm_obj_dbg (self, "(%s/%s) port allowed: device is allowlisted", subsystem, name);
         return TRUE;
     }
 
     /* If the device is explicitly blacklisted, we ignore every port. */
-    if ((self->priv->enabled_rules & MM_FILTER_RULE_EXPLICIT_BLACKLIST) &&
+    if ((self->priv->enabled_rules & MM_FILTER_RULE_EXPLICIT_BLOCKLIST) &&
         (mm_kernel_device_get_global_property_as_boolean (port, ID_MM_DEVICE_IGNORE))) {
-        mm_obj_dbg (self, "(%s/%s): port filtered: device is blacklisted", subsystem, name);
+        mm_obj_dbg (self, "(%s/%s): port filtered: device is blocklisted", subsystem, name);
         return FALSE;
     }
 
-    /* If the device is whitelisted by a plugin, we allow it. */
-    if (self->priv->enabled_rules & MM_FILTER_RULE_PLUGIN_WHITELIST) {
+    /* If the device is allowlisted by a plugin, we allow it. */
+    if (self->priv->enabled_rules & MM_FILTER_RULE_PLUGIN_ALLOWLIST) {
         GList   *l;
         guint16  vid = 0;
         guint16  pid = 0;
 
-        for (l = self->priv->plugin_whitelist_tags; l; l = g_list_next (l)) {
+        for (l = self->priv->plugin_allowlist_tags; l; l = g_list_next (l)) {
             if (mm_kernel_device_get_global_property_as_boolean (port, (const gchar *)(l->data)) ||
                 mm_kernel_device_get_property_as_boolean (port, (const gchar *)(l->data))) {
-                mm_obj_dbg (self, "(%s/%s) port allowed: device is whitelisted by plugin (tag)", subsystem, name);
+                mm_obj_dbg (self, "(%s/%s) port allowed: device is allowlisted by plugin (tag)", subsystem, name);
                 return TRUE;
             }
         }
@@ -149,29 +149,29 @@ mm_filter_port (MMFilter        *self,
         if (vid)
             pid = mm_kernel_device_get_physdev_pid (port);
 
-        if (vid && pid && self->priv->plugin_whitelist_product_ids) {
+        if (vid && pid && self->priv->plugin_allowlist_product_ids) {
             guint i;
 
-            for (i = 0; i < self->priv->plugin_whitelist_product_ids->len; i++) {
+            for (i = 0; i < self->priv->plugin_allowlist_product_ids->len; i++) {
                 mm_uint16_pair *item;
 
-                item = &g_array_index (self->priv->plugin_whitelist_product_ids, mm_uint16_pair, i);
+                item = &g_array_index (self->priv->plugin_allowlist_product_ids, mm_uint16_pair, i);
                 if (item->l == vid && item->r == pid) {
-                    mm_obj_dbg (self, "(%s/%s) port allowed: device is whitelisted by plugin (vid/pid)", subsystem, name);
+                    mm_obj_dbg (self, "(%s/%s) port allowed: device is allowlisted by plugin (vid/pid)", subsystem, name);
                     return TRUE;
                 }
             }
         }
 
-        if (vid && self->priv->plugin_whitelist_vendor_ids) {
+        if (vid && self->priv->plugin_allowlist_vendor_ids) {
             guint i;
 
-            for (i = 0; i < self->priv->plugin_whitelist_vendor_ids->len; i++) {
+            for (i = 0; i < self->priv->plugin_allowlist_vendor_ids->len; i++) {
                 guint16 item;
 
-                item = g_array_index (self->priv->plugin_whitelist_vendor_ids, guint16, i);
+                item = g_array_index (self->priv->plugin_allowlist_vendor_ids, guint16, i);
                 if (item == vid) {
-                    mm_obj_dbg (self, "(%s/%s) port allowed: device is whitelisted by plugin (vid)", subsystem, name);
+                    mm_obj_dbg (self, "(%s/%s) port allowed: device is allowlisted by plugin (vid)", subsystem, name);
                     return TRUE;
                 }
             }
@@ -228,9 +228,9 @@ mm_filter_port (MMFilter        *self,
         const gchar *physdev_subsystem;
         const gchar *driver;
 
-        /* Mixed blacklist/whitelist rules */
+        /* Mixed blocklist/allowlist rules */
 
-        /* If the physdev is a 'platform' or 'pnp' device that's not whitelisted, ignore it */
+        /* If the physdev is a 'platform' or 'pnp' device that's not allowlisted, ignore it */
         physdev_subsystem = mm_kernel_device_get_physdev_subsystem (port);
         if ((self->priv->enabled_rules & MM_FILTER_RULE_TTY_PLATFORM_DRIVER) &&
             (!g_strcmp0 (physdev_subsystem, "platform") ||
@@ -241,7 +241,7 @@ mm_filter_port (MMFilter        *self,
             return FALSE;
         }
 
-        /* Whitelist rules last */
+        /* Allowlist rules last */
 
         /* If the TTY kernel driver is one expected modem kernel driver, allow it */
         driver = mm_kernel_device_get_driver (port);
@@ -440,9 +440,9 @@ mm_filter_new (MMFilterRule   enabled_rules,
 #define RULE_ENABLED_STR(flag) ((self->priv->enabled_rules & flag) ? "yes" : "no")
 
     mm_obj_dbg (self, "created");
-    mm_obj_dbg (self, "  explicit whitelist:         %s", RULE_ENABLED_STR (MM_FILTER_RULE_EXPLICIT_WHITELIST));
-    mm_obj_dbg (self, "  explicit blacklist:         %s", RULE_ENABLED_STR (MM_FILTER_RULE_EXPLICIT_BLACKLIST));
-    mm_obj_dbg (self, "  plugin whitelist:           %s", RULE_ENABLED_STR (MM_FILTER_RULE_PLUGIN_WHITELIST));
+    mm_obj_dbg (self, "  explicit allowlist:         %s", RULE_ENABLED_STR (MM_FILTER_RULE_EXPLICIT_ALLOWLIST));
+    mm_obj_dbg (self, "  explicit blocklist:         %s", RULE_ENABLED_STR (MM_FILTER_RULE_EXPLICIT_BLOCKLIST));
+    mm_obj_dbg (self, "  plugin allowlist:           %s", RULE_ENABLED_STR (MM_FILTER_RULE_PLUGIN_ALLOWLIST));
     mm_obj_dbg (self, "  qrtr devices allowed:       %s", RULE_ENABLED_STR (MM_FILTER_RULE_QRTR));
     mm_obj_dbg (self, "  virtual devices forbidden:  %s", RULE_ENABLED_STR (MM_FILTER_RULE_VIRTUAL));
     mm_obj_dbg (self, "  net devices allowed:        %s", RULE_ENABLED_STR (MM_FILTER_RULE_NET));
@@ -514,9 +514,9 @@ finalize (GObject *object)
 {
     MMFilter *self = MM_FILTER (object);
 
-    g_clear_pointer (&self->priv->plugin_whitelist_vendor_ids, g_array_unref);
-    g_clear_pointer (&self->priv->plugin_whitelist_product_ids, g_array_unref);
-    g_list_free_full (self->priv->plugin_whitelist_tags, g_free);
+    g_clear_pointer (&self->priv->plugin_allowlist_vendor_ids, g_array_unref);
+    g_clear_pointer (&self->priv->plugin_allowlist_product_ids, g_array_unref);
+    g_list_free_full (self->priv->plugin_allowlist_tags, g_free);
 
     G_OBJECT_CLASS (mm_filter_parent_class)->finalize (object);
 }
diff --git a/src/mm-filter.h b/src/mm-filter.h
index 6c38568d..de561dab 100644
--- a/src/mm-filter.h
+++ b/src/mm-filter.h
@@ -47,9 +47,9 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMFilter, g_object_unref)
 
 typedef enum { /*< underscore_name=mm_filter_rule >*/
     MM_FILTER_RULE_NONE                  = 0,
-    MM_FILTER_RULE_EXPLICIT_WHITELIST    = 1 << 0,
-    MM_FILTER_RULE_EXPLICIT_BLACKLIST    = 1 << 1,
-    MM_FILTER_RULE_PLUGIN_WHITELIST      = 1 << 2,
+    MM_FILTER_RULE_EXPLICIT_ALLOWLIST    = 1 << 0,
+    MM_FILTER_RULE_EXPLICIT_BLOCKLIST    = 1 << 1,
+    MM_FILTER_RULE_PLUGIN_ALLOWLIST      = 1 << 2,
     MM_FILTER_RULE_QRTR                  = 1 << 3,
     MM_FILTER_RULE_VIRTUAL               = 1 << 4,
     MM_FILTER_RULE_NET                   = 1 << 5,
@@ -65,11 +65,11 @@ typedef enum { /*< underscore_name=mm_filter_rule >*/
 } MMFilterRule;
 
 /* This is a stricter policy which will only automatically probe device ports
- * if they are allowed by any of the automatic whitelist rules. */
+ * if they are allowed by any of the automatic allowlist rules. */
 #define MM_FILTER_POLICY_STRICT             \
-    (MM_FILTER_RULE_EXPLICIT_WHITELIST    | \
-     MM_FILTER_RULE_EXPLICIT_BLACKLIST    | \
-     MM_FILTER_RULE_PLUGIN_WHITELIST      | \
+    (MM_FILTER_RULE_EXPLICIT_ALLOWLIST    | \
+     MM_FILTER_RULE_EXPLICIT_BLOCKLIST    | \
+     MM_FILTER_RULE_PLUGIN_ALLOWLIST      | \
      MM_FILTER_RULE_QRTR                  | \
      MM_FILTER_RULE_VIRTUAL               | \
      MM_FILTER_RULE_NET                   | \
@@ -83,9 +83,9 @@ typedef enum { /*< underscore_name=mm_filter_rule >*/
      MM_FILTER_RULE_TTY_WITH_NET          | \
      MM_FILTER_RULE_TTY_DEFAULT_FORBIDDEN)
 
-/* This policy only allows using device ports explicitly whitelisted via
+/* This policy only allows using device ports explicitly allowlisted via
  * udev rules. i.e. ModemManager won't do any kind of automatic probing. */
-#define MM_FILTER_POLICY_WHITELIST_ONLY MM_FILTER_RULE_EXPLICIT_WHITELIST
+#define MM_FILTER_POLICY_ALLOWLIST_ONLY MM_FILTER_RULE_EXPLICIT_ALLOWLIST
 
 /* The strict policy has all supported rules */
 #define MM_FILTER_RULE_ALL MM_FILTER_POLICY_STRICT
@@ -101,11 +101,11 @@ gboolean mm_filter_device_and_port (MMFilter       *self,
                                     MMDevice       *device,
                                     MMKernelDevice *port);
 
-void     mm_filter_register_plugin_whitelist_tag        (MMFilter    *self,
+void     mm_filter_register_plugin_allowlist_tag        (MMFilter    *self,
                                                          const gchar *tag);
-void     mm_filter_register_plugin_whitelist_vendor_id  (MMFilter    *self,
+void     mm_filter_register_plugin_allowlist_vendor_id  (MMFilter    *self,
                                                          guint16      vid);
-void     mm_filter_register_plugin_whitelist_product_id (MMFilter    *self,
+void     mm_filter_register_plugin_allowlist_product_id (MMFilter    *self,
                                                          guint16      vid,
                                                          guint16      pid);
 
diff --git a/src/mm-plugin-manager.c b/src/mm-plugin-manager.c
index 4e9f3008..f0bdba0d 100644
--- a/src/mm-plugin-manager.c
+++ b/src/mm-plugin-manager.c
@@ -1614,48 +1614,48 @@ mm_plugin_manager_get_subsystems (MMPluginManager *self)
 /*****************************************************************************/
 
 static void
-register_plugin_whitelist_tags (MMPluginManager *self,
+register_plugin_allowlist_tags (MMPluginManager *self,
                                 MMPlugin        *plugin)
 {
     const gchar **tags;
     guint         i;
 
-    if (!mm_filter_check_rule_enabled (self->priv->filter, MM_FILTER_RULE_PLUGIN_WHITELIST))
+    if (!mm_filter_check_rule_enabled (self->priv->filter, MM_FILTER_RULE_PLUGIN_ALLOWLIST))
         return;
 
     tags = mm_plugin_get_allowed_udev_tags (plugin);
     for (i = 0; tags && tags[i]; i++)
-        mm_filter_register_plugin_whitelist_tag (self->priv->filter, tags[i]);
+        mm_filter_register_plugin_allowlist_tag (self->priv->filter, tags[i]);
 }
 
 static void
-register_plugin_whitelist_vendor_ids (MMPluginManager *self,
+register_plugin_allowlist_vendor_ids (MMPluginManager *self,
                                        MMPlugin        *plugin)
 {
     const guint16 *vendor_ids;
     guint          i;
 
-    if (!mm_filter_check_rule_enabled (self->priv->filter, MM_FILTER_RULE_PLUGIN_WHITELIST))
+    if (!mm_filter_check_rule_enabled (self->priv->filter, MM_FILTER_RULE_PLUGIN_ALLOWLIST))
         return;
 
     vendor_ids = mm_plugin_get_allowed_vendor_ids (plugin);
     for (i = 0; vendor_ids && vendor_ids[i]; i++)
-        mm_filter_register_plugin_whitelist_vendor_id (self->priv->filter, vendor_ids[i]);
+        mm_filter_register_plugin_allowlist_vendor_id (self->priv->filter, vendor_ids[i]);
 }
 
 static void
-register_plugin_whitelist_product_ids (MMPluginManager *self,
+register_plugin_allowlist_product_ids (MMPluginManager *self,
                                        MMPlugin        *plugin)
 {
     const mm_uint16_pair *product_ids;
     guint                 i;
 
-    if (!mm_filter_check_rule_enabled (self->priv->filter, MM_FILTER_RULE_PLUGIN_WHITELIST))
+    if (!mm_filter_check_rule_enabled (self->priv->filter, MM_FILTER_RULE_PLUGIN_ALLOWLIST))
         return;
 
     product_ids = mm_plugin_get_allowed_product_ids (plugin);
     for (i = 0; product_ids && product_ids[i].l; i++)
-        mm_filter_register_plugin_whitelist_product_id (self->priv->filter, product_ids[i].l, product_ids[i].r);
+        mm_filter_register_plugin_allowlist_product_id (self->priv->filter, product_ids[i].l, product_ids[i].r);
 }
 
 static MMPlugin *
@@ -1860,10 +1860,10 @@ load_plugins (MMPluginManager  *self,
                 g_ptr_array_add (subsystems, g_strdup (plugin_subsystems[i]));
         }
 
-        /* Register plugin whitelist rules in filter, if any */
-        register_plugin_whitelist_tags        (self, plugin);
-        register_plugin_whitelist_vendor_ids  (self, plugin);
-        register_plugin_whitelist_product_ids (self, plugin);
+        /* Register plugin allowlist rules in filter, if any */
+        register_plugin_allowlist_tags        (self, plugin);
+        register_plugin_allowlist_vendor_ids  (self, plugin);
+        register_plugin_allowlist_product_ids (self, plugin);
     }
 
     /* Check the generic plugin once all looped */