From: Benjamin Berg <benjamin.berg(a)intel.com>
The normal timer mechanism assume that timeout further in the future
need a lower accuracy. As an example, the granularity for a timer
scheduled 4096 ms in the future on a 1000 Hz system is already 512 ms.
This granularity is perfectly sufficient for e.g. timeouts, but there
are other types of events that will happen at a future point in time and
require a higher accuracy.
Add a new wiphy_hrtimer_work type that uses an hrtimer internally. The
API is almost identical to the existing wiphy_delayed_work and it can be
used as a drop-in replacement after minor adjustments. The work will be
scheduled relative to the current time with a slack of 1 millisecond.
CC: stable(a)vger.kernel.org # 6.4+
Signed-off-by: Benjamin Berg <benjamin.berg(a)intel.com>
Reviewed-by: Johannes Berg <johannes.berg(a)intel.com>
Signed-off-by: Miri Korenblit <miriam.rachel.korenblit(a)intel.com>
---
include/net/cfg80211.h | 78 ++++++++++++++++++++++++++++++++++++++++++
net/wireless/core.c | 56 ++++++++++++++++++++++++++++++
net/wireless/trace.h | 21 ++++++++++++
3 files changed, 155 insertions(+)
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 53490eb04e87..f2e8963cfaac 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -6440,6 +6440,11 @@ static inline void wiphy_delayed_work_init(struct wiphy_delayed_work *dwork,
* after wiphy_lock() was called. Therefore, wiphy_cancel_work() can
* use just cancel_work() instead of cancel_work_sync(), it requires
* being in a section protected by wiphy_lock().
+ *
+ * Note that these are scheduled with a timer where the accuracy
+ * becomes less the longer in the future the scheduled timer is. Use
+ * wiphy_hrtimer_work_queue() if the timer must be not be late by more
+ * than approximately 10 percent.
*/
void wiphy_delayed_work_queue(struct wiphy *wiphy,
struct wiphy_delayed_work *dwork,
@@ -6511,6 +6516,79 @@ void wiphy_delayed_work_flush(struct wiphy *wiphy,
bool wiphy_delayed_work_pending(struct wiphy *wiphy,
struct wiphy_delayed_work *dwork);
+struct wiphy_hrtimer_work {
+ struct wiphy_work work;
+ struct wiphy *wiphy;
+ struct hrtimer timer;
+};
+
+enum hrtimer_restart wiphy_hrtimer_work_timer(struct hrtimer *t);
+
+static inline void wiphy_hrtimer_work_init(struct wiphy_hrtimer_work *hrwork,
+ wiphy_work_func_t func)
+{
+ hrtimer_setup(&hrwork->timer, wiphy_hrtimer_work_timer,
+ CLOCK_BOOTTIME, HRTIMER_MODE_REL);
+ wiphy_work_init(&hrwork->work, func);
+}
+
+/**
+ * wiphy_hrtimer_work_queue - queue hrtimer work for the wiphy
+ * @wiphy: the wiphy to queue for
+ * @hrwork: the high resolution timer worker
+ * @delay: the delay given as a ktime_t
+ *
+ * Please refer to wiphy_delayed_work_queue(). The difference is that
+ * the hrtimer work uses a high resolution timer for scheduling. This
+ * may be needed if timeouts might be scheduled further in the future
+ * and the accuracy of the normal timer is not sufficient.
+ *
+ * Expect a delay of a few milliseconds as the timer is scheduled
+ * with some slack and some more time may pass between queueing the
+ * work and its start.
+ */
+void wiphy_hrtimer_work_queue(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork,
+ ktime_t delay);
+
+/**
+ * wiphy_hrtimer_work_cancel - cancel previously queued hrtimer work
+ * @wiphy: the wiphy, for debug purposes
+ * @hrtimer: the hrtimer work to cancel
+ *
+ * Cancel the work *without* waiting for it, this assumes being
+ * called under the wiphy mutex acquired by wiphy_lock().
+ */
+void wiphy_hrtimer_work_cancel(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrtimer);
+
+/**
+ * wiphy_hrtimer_work_flush - flush previously queued hrtimer work
+ * @wiphy: the wiphy, for debug purposes
+ * @hrwork: the hrtimer work to flush
+ *
+ * Flush the work (i.e. run it if pending). This must be called
+ * under the wiphy mutex acquired by wiphy_lock().
+ */
+void wiphy_hrtimer_work_flush(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork);
+
+/**
+ * wiphy_hrtimer_work_pending - Find out whether a wiphy hrtimer
+ * work item is currently pending.
+ *
+ * @wiphy: the wiphy, for debug purposes
+ * @hrwork: the hrtimer work in question
+ *
+ * Return: true if timer is pending, false otherwise
+ *
+ * Please refer to the wiphy_delayed_work_pending() documentation as
+ * this is the equivalent function for hrtimer based delayed work
+ * items.
+ */
+bool wiphy_hrtimer_work_pending(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork);
+
/**
* enum ieee80211_ap_reg_power - regulatory power for an Access Point
*
diff --git a/net/wireless/core.c b/net/wireless/core.c
index f3568eb5e592..9f858a83e912 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -1802,6 +1802,62 @@ bool wiphy_delayed_work_pending(struct wiphy *wiphy,
}
EXPORT_SYMBOL_GPL(wiphy_delayed_work_pending);
+enum hrtimer_restart wiphy_hrtimer_work_timer(struct hrtimer *t)
+{
+ struct wiphy_hrtimer_work *hrwork =
+ container_of(t, struct wiphy_hrtimer_work, timer);
+
+ wiphy_work_queue(hrwork->wiphy, &hrwork->work);
+
+ return HRTIMER_NORESTART;
+}
+EXPORT_SYMBOL_GPL(wiphy_hrtimer_work_timer);
+
+void wiphy_hrtimer_work_queue(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork,
+ ktime_t delay)
+{
+ trace_wiphy_hrtimer_work_queue(wiphy, &hrwork->work, delay);
+
+ if (!delay) {
+ hrtimer_cancel(&hrwork->timer);
+ wiphy_work_queue(wiphy, &hrwork->work);
+ return;
+ }
+
+ hrwork->wiphy = wiphy;
+ hrtimer_start_range_ns(&hrwork->timer, delay,
+ 1000 * NSEC_PER_USEC, HRTIMER_MODE_REL);
+}
+EXPORT_SYMBOL_GPL(wiphy_hrtimer_work_queue);
+
+void wiphy_hrtimer_work_cancel(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork)
+{
+ lockdep_assert_held(&wiphy->mtx);
+
+ hrtimer_cancel(&hrwork->timer);
+ wiphy_work_cancel(wiphy, &hrwork->work);
+}
+EXPORT_SYMBOL_GPL(wiphy_hrtimer_work_cancel);
+
+void wiphy_hrtimer_work_flush(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork)
+{
+ lockdep_assert_held(&wiphy->mtx);
+
+ hrtimer_cancel(&hrwork->timer);
+ wiphy_work_flush(wiphy, &hrwork->work);
+}
+EXPORT_SYMBOL_GPL(wiphy_hrtimer_work_flush);
+
+bool wiphy_hrtimer_work_pending(struct wiphy *wiphy,
+ struct wiphy_hrtimer_work *hrwork)
+{
+ return hrtimer_is_queued(&hrwork->timer);
+}
+EXPORT_SYMBOL_GPL(wiphy_hrtimer_work_pending);
+
static int __init cfg80211_init(void)
{
int err;
diff --git a/net/wireless/trace.h b/net/wireless/trace.h
index 8a4c34112eb5..2b71f1d867a0 100644
--- a/net/wireless/trace.h
+++ b/net/wireless/trace.h
@@ -304,6 +304,27 @@ TRACE_EVENT(wiphy_delayed_work_queue,
__entry->delay)
);
+TRACE_EVENT(wiphy_hrtimer_work_queue,
+ TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work,
+ ktime_t delay),
+ TP_ARGS(wiphy, work, delay),
+ TP_STRUCT__entry(
+ WIPHY_ENTRY
+ __field(void *, instance)
+ __field(void *, func)
+ __field(ktime_t, delay)
+ ),
+ TP_fast_assign(
+ WIPHY_ASSIGN;
+ __entry->instance = work;
+ __entry->func = work->func;
+ __entry->delay = delay;
+ ),
+ TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%llu",
+ WIPHY_PR_ARG, __entry->instance, __entry->func,
+ __entry->delay)
+);
+
TRACE_EVENT(wiphy_work_worker_start,
TP_PROTO(struct wiphy *wiphy),
TP_ARGS(wiphy),
--
2.34.1
When kvrealloc() fails, the original markers memory is leaked
because the function directly assigns the NULL to the markers pointer,
losing the reference to the original memory.
As a result, the kvfree() in pt_dump_init() ends up freeing NULL instead
of the previously allocated memory.
Fix this by using a temporary variable to store kvrealloc()'s return
value and only update the markers pointer on success.
Found via static anlaysis and this is similar to commit 42378a9ca553
("bpf, verifier: Fix memory leak in array reallocation for stack state")
Fixes: d0e7915d2ad3 ("s390/mm/ptdump: Generate address marker array dynamically")
Cc: stable(a)vger.kernel.org
Signed-off-by: Miaoqian Lin <linmq006(a)gmail.com>
---
arch/s390/mm/dump_pagetables.c | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/arch/s390/mm/dump_pagetables.c b/arch/s390/mm/dump_pagetables.c
index 9af2aae0a515..0f2e0c93a1e0 100644
--- a/arch/s390/mm/dump_pagetables.c
+++ b/arch/s390/mm/dump_pagetables.c
@@ -291,16 +291,19 @@ static int ptdump_cmp(const void *a, const void *b)
static int add_marker(unsigned long start, unsigned long end, const char *name)
{
+ struct addr_marker *new_markers;
size_t oldsize, newsize;
oldsize = markers_cnt * sizeof(*markers);
newsize = oldsize + 2 * sizeof(*markers);
if (!oldsize)
- markers = kvmalloc(newsize, GFP_KERNEL);
+ new_markers = kvmalloc(newsize, GFP_KERNEL);
else
- markers = kvrealloc(markers, newsize, GFP_KERNEL);
- if (!markers)
+ new_markers = kvrealloc(markers, newsize, GFP_KERNEL);
+ if (!new_markers)
goto error;
+
+ markers = new_markers;
markers[markers_cnt].is_start = 1;
markers[markers_cnt].start_address = start;
markers[markers_cnt].size = end - start;
--
2.39.5 (Apple Git-154)
The patch below does not apply to the 5.10-stable tree.
If someone wants it applied there, or to any other stable or longterm
tree, then please email the backport, including the original git commit
id to <stable(a)vger.kernel.org>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.10.y
git checkout FETCH_HEAD
git cherry-pick -x f7c877e7535260cc7a21484c994e8ce7e8cb6780
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<stable(a)vger.kernel.org>' --in-reply-to '2025102616-navy-creatable-7fad@gregkh' --subject-prefix 'PATCH 5.10.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From f7c877e7535260cc7a21484c994e8ce7e8cb6780 Mon Sep 17 00:00:00 2001
From: Stefano Garzarella <sgarzare(a)redhat.com>
Date: Tue, 21 Oct 2025 14:17:18 +0200
Subject: [PATCH] vsock: fix lock inversion in vsock_assign_transport()
Syzbot reported a potential lock inversion deadlock between
vsock_register_mutex and sk_lock-AF_VSOCK when vsock_linger() is called.
The issue was introduced by commit 687aa0c5581b ("vsock: Fix
transport_* TOCTOU") which added vsock_register_mutex locking in
vsock_assign_transport() around the transport->release() call, that can
call vsock_linger(). vsock_assign_transport() can be called with sk_lock
held. vsock_linger() calls sk_wait_event() that temporarily releases and
re-acquires sk_lock. During this window, if another thread hold
vsock_register_mutex while trying to acquire sk_lock, a circular
dependency is created.
Fix this by releasing vsock_register_mutex before calling
transport->release() and vsock_deassign_transport(). This is safe
because we don't need to hold vsock_register_mutex while releasing the
old transport, and we ensure the new transport won't disappear by
obtaining a module reference first via try_module_get().
Reported-by: syzbot+10e35716f8e4929681fa(a)syzkaller.appspotmail.com
Tested-by: syzbot+10e35716f8e4929681fa(a)syzkaller.appspotmail.com
Fixes: 687aa0c5581b ("vsock: Fix transport_* TOCTOU")
Cc: mhal(a)rbox.co
Cc: stable(a)vger.kernel.org
Signed-off-by: Stefano Garzarella <sgarzare(a)redhat.com>
Link: https://patch.msgid.link/20251021121718.137668-1-sgarzare@redhat.com
Signed-off-by: Paolo Abeni <pabeni(a)redhat.com>
diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
index 4c2db6cca557..76763247a377 100644
--- a/net/vmw_vsock/af_vsock.c
+++ b/net/vmw_vsock/af_vsock.c
@@ -487,12 +487,26 @@ int vsock_assign_transport(struct vsock_sock *vsk, struct vsock_sock *psk)
goto err;
}
- if (vsk->transport) {
- if (vsk->transport == new_transport) {
- ret = 0;
- goto err;
- }
+ if (vsk->transport && vsk->transport == new_transport) {
+ ret = 0;
+ goto err;
+ }
+ /* We increase the module refcnt to prevent the transport unloading
+ * while there are open sockets assigned to it.
+ */
+ if (!new_transport || !try_module_get(new_transport->module)) {
+ ret = -ENODEV;
+ goto err;
+ }
+
+ /* It's safe to release the mutex after a successful try_module_get().
+ * Whichever transport `new_transport` points at, it won't go away until
+ * the last module_put() below or in vsock_deassign_transport().
+ */
+ mutex_unlock(&vsock_register_mutex);
+
+ if (vsk->transport) {
/* transport->release() must be called with sock lock acquired.
* This path can only be taken during vsock_connect(), where we
* have already held the sock lock. In the other cases, this
@@ -512,20 +526,6 @@ int vsock_assign_transport(struct vsock_sock *vsk, struct vsock_sock *psk)
vsk->peer_shutdown = 0;
}
- /* We increase the module refcnt to prevent the transport unloading
- * while there are open sockets assigned to it.
- */
- if (!new_transport || !try_module_get(new_transport->module)) {
- ret = -ENODEV;
- goto err;
- }
-
- /* It's safe to release the mutex after a successful try_module_get().
- * Whichever transport `new_transport` points at, it won't go away until
- * the last module_put() below or in vsock_deassign_transport().
- */
- mutex_unlock(&vsock_register_mutex);
-
if (sk->sk_type == SOCK_SEQPACKET) {
if (!new_transport->seqpacket_allow ||
!new_transport->seqpacket_allow(remote_cid)) {
The driver_find_device() function returns a device with its reference
count incremented. The caller is responsible for calling put_device()
to release this reference when done. Fix this leak by adding the missing
put_device() call.
Found via static analysis.
Fixes: f68ba6912bd2 ("drm/tegra: dc: Link DC1 to DC0 on Tegra20")
Cc: stable(a)vger.kernel.org
Signed-off-by: Miaoqian Lin <linmq006(a)gmail.com>
---
drivers/gpu/drm/tegra/dc.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c
index 59d5c1ba145a..6c84bd69b11f 100644
--- a/drivers/gpu/drm/tegra/dc.c
+++ b/drivers/gpu/drm/tegra/dc.c
@@ -3148,6 +3148,7 @@ static int tegra_dc_couple(struct tegra_dc *dc)
dc->client.parent = &parent->client;
dev_dbg(dc->dev, "coupled to %s\n", dev_name(companion));
+ put_device(companion);
}
return 0;
--
2.39.5 (Apple Git-154)
From: Wang Haoran <haoranwangsec(a)gmail.com>
commit 27e06650a5eafe832a90fd2604f0c5e920857fae upstream.
A buffer overflow arises from the usage of snprintf to write into the
buffer "buf" in target_lu_gp_members_show function located in
/drivers/target/target_core_configfs.c. This buffer is allocated with
size LU_GROUP_NAME_BUF (256 bytes).
snprintf(...) formats multiple strings into buf with the HBA name
(hba->hba_group.cg_item), a slash character, a devicename (dev->
dev_group.cg_item) and a newline character, the total formatted string
length may exceed the buffer size of 256 bytes.
Since snprintf() returns the total number of bytes that would have been
written (the length of %s/%sn ), this value may exceed the buffer length
(256 bytes) passed to memcpy(), this will ultimately cause function
memcpy reporting a buffer overflow error.
An additional check of the return value of snprintf() can avoid this
buffer overflow.
Reported-by: Wang Haoran <haoranwangsec(a)gmail.com>
Reported-by: ziiiro <yuanmingbuaa(a)gmail.com>
Signed-off-by: Wang Haoran <haoranwangsec(a)gmail.com>
Signed-off-by: Martin K. Petersen <martin.petersen(a)oracle.com>
[Andrey Troshin: patch adaptation for linux-5.10]
Signed-off-by: Andrey Troshin <drtrosh(a)yandex-team.ru>
---
Backport fix for CVE-2025-39998
Link: https://nvd.nist.gov/vuln/detail/CVE-2025-39998
---
drivers/target/target_core_configfs.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 4d2fbe1429b6..e6996428c07d 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -2637,7 +2637,7 @@ static ssize_t target_lu_gp_members_show(struct config_item *item, char *page)
config_item_name(&dev->dev_group.cg_item));
cur_len++; /* Extra byte for NULL terminator */
- if ((cur_len + len) > PAGE_SIZE) {
+ if ((cur_len + len) > PAGE_SIZE || cur_len > LU_GROUP_NAME_BUF) {
pr_warn("Ran out of lu_gp_show_attr"
"_members buffer\n");
break;
--
2.34.1
📞 For the fastest help, call Play Airlines customer support at 1-866-284-3022. Their agents are trained to assist with name corrections.
✍️ Did you book a flight with Play Airlines and realize your name is misspelled or needs updating? Whether it is a minor typo or a legal name change, it is essential to correct your flight details before travel to avoid problems at check-in. Fortunately, Play Airlines offers options for name changes or corrections — and we are here to guide you through the process, step by step.
📌 Why Name Corrections Matter
Airlines require that the name on your ticket exactly matches the name on your government-issued ID or passport. Even a small typo can result in:
❌ Denied boarding
❌ TSA security issues
❌ Non-refundable tickets going to waste
That is why it is important to act quickly if you notice an error.
👉 Pro Tip: As soon as you spot an issue with your name, call 1-866-284-3022 to fix it directly with Play Airlines.
📋 Play Airlines Name Correction Policy: The Basics
Play Airlines does allow name corrections and changes, but there are specific rules based on the type and extent of the correction.
✏️ Minor Name Corrections
If your correction is minor (e.g., spelling mistake, missing middle name, or nickname to legal name), it is usually easy to fix.
Examples:
• “Jonh” to “John”
• “Liz” to “Elizabeth”
• Missing middle name or incorrect initials
🟢 These are typically allowed once per passenger. Call 📞 1-866-284-3022 to request a minor correction. You may need to provide identification or legal documentation.
🔄 Major Name Changes
For legal name changes due to:
• Marriage 👰
• Divorce 💔
• Legal court order 📄
You will likely be required to submit legal documents (e.g., marriage certificate, divorce decree, or court papers).
Important: Name changes are different from transferring your ticket to someone else — Sun Country does not allow name transfers. The passenger must remain the same person.
📞 For clarity and assistance, it is best to speak to a representative at 1-866-284-3022.
💰 Are There Any Fees for Name Changes?
Yes, in most cases, Sun Country charges a name change or correction fee, which may vary depending on:
• The type of fare you purchased
• How close it is to your departure date
• Whether the change is made online or via customer service
Fees can range from $75 to $150, though minor corrections may be less, especially if made within 24 hours of booking.
🎯 To get an accurate quote and understand your options, call 1-866-284-3022 and speak with a Sun Country agent.
🌐 How to Request a Name Correction
There are two main ways to request a name correction on your Play Airlines ticket:
✅ 1. Call Customer Support (Recommended)
📞 Dial 1-866-284-3022
📄 Provide your confirmation number, full incorrect name, and the correct name
🧾 Have a valid ID or legal document ready, if needed
🎟️ The agent will process the change and send you an updated itinerary
Calling ensures faster processing and personalized help.
💻 2. Manage Booking Online
While not all name changes can be made online, you can attempt to:
1. Visit official Sun Country website
2. Click on "My Trips"
3. Enter your last name and confirmation code
4. Look for an option to edit passenger details
📌 If you cannot make changes online, revert to calling 📞 1-866-284-3022.
⏱️ Time-Sensitive Corrections: Act Fast!
If your flight is within 24 to 48 hours, do not delay. Last-minute changes can be harder to process and may result in additional fees or denied boarding.
🚨 Urgent situations? Call 📞 1-866-284-3022 immediately. Sun Country's support team can walk you through your options quickly.
✍️ Final Checklist Before You Travel
✅ Name on your ticket matches your ID
✅ You've received an updated confirmation email
✅ You've saved all receipts and documents related to the name correction
✅ You have confirmed there are no other errors in your booking (dates, destinations, etc.)
📞 Need Help? Call Play Airlines Anytime
Whether you are unsure if your change qualifies or you just want confirmation, don’t hesitate to call Play Airlines at 1-866-284-3022. Their support agents are available to:
• Handle name corrections
• Answer policy questions
• Assist with legal document submissions
• Avoid unnecessary delays or cancellations
🧳 In Summary
Mistakes happen — but with Play Airlines, correcting a name on your flight reservation does not have to be stressful. The key is to act fast, follow the policy, and use the right contact channels.
🛑 Do NOT ignore a misspelled name
📞 ALWAYS call 1-866-284-3022 for support
📧 Double-check your confirmation email
📅 Fix issues well before your travel date
Safe travels — and smooth corrections!
📞 For the fastest help, call Aer Lingus customer support at 1-866-284-3022. Their agents are trained to assist with name corrections.
✍️ Did you book a flight with Aer Lingus and realize your name is misspelled or needs updating? Whether it is a minor typo or a legal name change, it is essential to correct your flight details before travel to avoid problems at check-in. Fortunately, Aer Lingus offers options for name changes or corrections — and we are here to guide you through the process, step by step.
📌 Why Name Corrections Matter
Airlines require that the name on your ticket exactly matches the name on your government-issued ID or passport. Even a small typo can result in:
❌ Denied boarding
❌ TSA security issues
❌ Non-refundable tickets going to waste
That is why it is important to act quickly if you notice an error.
👉 Pro Tip: As soon as you spot an issue with your name, call 1-866-284-3022 to fix it directly with Aer Lingus.
📋 Aer Lingus Name Correction Policy: The Basics
Aer Lingus does allow name corrections and changes, but there are specific rules based on the type and extent of the correction.
✏️ Minor Name Corrections
If your correction is minor (e.g., spelling mistake, missing middle name, or nickname to legal name), it is usually easy to fix.
Examples:
• “Jonh” to “John”
• “Liz” to “Elizabeth”
• Missing middle name or incorrect initials
🟢 These are typically allowed once per passenger. Call 📞 1-866-284-3022 to request a minor correction. You may need to provide identification or legal documentation.
🔄 Major Name Changes
For legal name changes due to:
• Marriage 👰
• Divorce 💔
• Legal court order 📄
You will likely be required to submit legal documents (e.g., marriage certificate, divorce decree, or court papers).
Important: Name changes are different from transferring your ticket to someone else — Sun Country does not allow name transfers. The passenger must remain the same person.
📞 For clarity and assistance, it is best to speak to a representative at 1-866-284-3022.
💰 Are There Any Fees for Name Changes?
Yes, in most cases, Sun Country charges a name change or correction fee, which may vary depending on:
• The type of fare you purchased
• How close it is to your departure date
• Whether the change is made online or via customer service
Fees can range from $75 to $150, though minor corrections may be less, especially if made within 24 hours of booking.
🎯 To get an accurate quote and understand your options, call 1-866-284-3022 and speak with a Sun Country agent.
🌐 How to Request a Name Correction
There are two main ways to request a name correction on your Aer Lingus ticket:
✅ 1. Call Customer Support (Recommended)
📞 Dial 1-866-284-3022
📄 Provide your confirmation number, full incorrect name, and the correct name
🧾 Have a valid ID or legal document ready, if needed
🎟️ The agent will process the change and send you an updated itinerary
Calling ensures faster processing and personalized help.
💻 2. Manage Booking Online
While not all name changes can be made online, you can attempt to:
1. Visit official Sun Country website
2. Click on "My Trips"
3. Enter your last name and confirmation code
4. Look for an option to edit passenger details
📌 If you cannot make changes online, revert to calling 📞 1-866-284-3022.
⏱️ Time-Sensitive Corrections: Act Fast!
If your flight is within 24 to 48 hours, do not delay. Last-minute changes can be harder to process and may result in additional fees or denied boarding.
🚨 Urgent situations? Call 📞 1-866-284-3022 immediately. Sun Country's support team can walk you through your options quickly.
✍️ Final Checklist Before You Travel
✅ Name on your ticket matches your ID
✅ You've received an updated confirmation email
✅ You've saved all receipts and documents related to the name correction
✅ You have confirmed there are no other errors in your booking (dates, destinations, etc.)
📞 Need Help? Call Aer Lingus Anytime
Whether you are unsure if your change qualifies or you just want confirmation, don’t hesitate to call Aer Lingus at 1-866-284-3022. Their support agents are available to:
• Handle name corrections
• Answer policy questions
• Assist with legal document submissions
• Avoid unnecessary delays or cancellations
🧳 In Summary
Mistakes happen — but with Aer Lingus, correcting a name on your flight reservation does not have to be stressful. The key is to act fast, follow the policy, and use the right contact channels.
🛑 Do NOT ignore a misspelled name
📞 ALWAYS call 1-866-284-3022 for support
📧 Double-check your confirmation email
📅 Fix issues well before your travel date
Safe travels — and smooth corrections!