April 24, 2024

Linux has by no means suffered from the notorious BSoD, quick for blue display of dying, the identify given to the dreaded “one thing went terribly unsuitable” message related to a Home windows system crash.

Microsoft has tried many issues over time to shake that nickname “BSoD”, together with altering the background color used when crash messages seem, including a super-sized sad-face emoticon to make the message really feel extra compassionate, displaying QR codes which you can snap together with your telephone that can assist you diagnose the issue, and never filling the display with a technobabble record of kernel code objects that simply occurred to be loaded on the time.

(These crash dump lists usually led to anti-virus and threat-prevention software program being blamed for each system crash, just because their names tended to present up at or close to the highest of the record of loaded modules – not as a result of that they had something to do with the crash, however as a result of they typically loaded early on and simply occurred to be on the prime of the record, thus making a handy scaepgoat.)

Even higher, “BSoD” is now not the on a regular basis, throwaway pejorative time period that it was, as a result of Home windows crashes so much much less usually than it used to.

We’re not suggesting that Home windows by no means crashes, or imlying that it’s now magically bug-free; merely noting that you just usually don’t want the phrase BSoD as usually as you used to.

Linux crash notifications

In fact, Linux has by no means had BSoDs, not even again when Home windows appeared to have them on a regular basis, however that’s not as a result of Linux by no means crashes, or is magically bug-free.

It’s merely that Linux does’t BSoD (sure, the time period can be utilized as an intransitive verb, as in “my laptop computer BSoDded half means by way of an electronic mail”), as a result of – in a pleasant understatment – it suffers an oops, or if the oops is extreme sufficient that the system can’t reliably keep up even with degraded efficiency, it panics.

(It’s additionally attainable to configure a Linux kernel in order that an oops all the time get “promoted” to a panic, for environments the place safety issues make it higher to have a system that shuts down abruptly, albeit with some knowledge not getting saved in time, than a system that results in an unsure state that would result in knowledge leakage or knowledge corruption.)

An oops sometimes produces console output one thing like this (we’ve supplied supply code beneath if you wish to discover oopses and panics for your self):

[12710.153112] oops init (degree = 1)
[12710.153115] triggering oops through BUG()
[12710.153127] ------------[ cut here ]------------
[12710.153128] kernel BUG at /house/duck/Articles/linuxoops/oops.c:17!
[12710.153132] invalid opcode: 0000 [#1] PREEMPT SMP PTI
[12710.153748] CPU: 0 PID: 5531 Comm: insmod . . . 
[12710.154322] {Hardware} identify: XXXX
[12710.154940] RIP: 0010:oopsinit+0x3a/0xfc0 [oops]
[12710.155548] Code: . . . . .
[12710.156191] RSP: . . .  EFLAGS: . . .
[12710.156849] RAX: . . .  RBX: . . .  RCX: . . .
[12710.157513] RDX: . . .  RSI: . . .  RDI: . . .
[12710.158171] RBP: . . .  R08: . . .  R09: . . .
[12710.158826] R10: . . .  R11: . . .  R12: . . .
[12710.159483] R13: . . .  R14: . . .  R15: . . .
[12710.160143] FS:  . . .  GS: . . .  knlGS: . . . 
. . . . .
[12710.163474] Name Hint:
[12710.164779]  do_one_initcall+0x56/0x230
[12710.165424]  do_init_module+0x4a/0x210
[12710.166050]  __do_sys_finit_module+0x9e/0xf0
[12710.166711]  do_syscall_64+0x37/0x90
[12710.167320]  entry_SYSCALL_64_after_hwframe+0x72/0xdc
[12710.167958] RIP: 0033:0x7f6c28b15e39
[12710.168578] Code: . . . . .
[. . . . .
[12710.174032] Modules linked in: . . . . .
[12710.180294] ---[ end trace 0000000000000000 ]---

Sadly, when kernel model 6.2.3 got here out on the finish of final week, two tiny modifications rapidly proved to be problematic, with customers reporting kernel oopses when managing disk storage.

Kernel 6.1.16 was apparently topic to the identical modifications, and thus susceptible to the identical oopsiness.

For instance, plugging in an detachable drive and mounting it labored tremendous, however unmounting the drive while you’d completed with it might trigger an oops.

Though an oops doesn’t instantly freeze the entire pc, kernel-level code crashes when umounting disk storage are worrisone sufficient {that a} well-informed consumer would in all probability wish to shut down as quickly as attainable, in case of ongoing hassle resulting in knowledge corruption…

…however some customers reported that the oops prevented what’s identified within the jargon as an orderly shutdown, requiring forcibly biking the ability, by holding down the ability button for a number of seconds, or briefly slicing the mains provide to a server.

The excellent news is that kernels 6.2.4 and 6.1.17 have been instantly launched over the weekend to roll again the issues.

Given the speed of Linux kernel releases, these updates have already been adopted by 6.2.5 and 6.1.18, which have been themselves up to date (at this time, 2023-03-13) by 6.2.6 and 6.1.19.

What to do?

If you’re utilizing a 6.x-version Linux kernel and also you aren’t already bang up-to-date, ensure you don’t set up 6.2.3 or 6.1.16 alongside the best way.

In the event you’ve already obtained a type of variations (we had 6.2.3 for a few days and have been unable to impress a driver crash, presumably as a result of our kernel configuration shielded us inadvertently from triggering the bug), contemplate updating as quickly as you’ll be able to…

…as a result of even for those who haven’t suffered any disk-volume-based hassle to this point, chances are you’ll be immune by luck, however by upgrading your kernel once more you’ll change into immune by design.


You’ll need a kernel constructed from supply code that’s already put in in your check pc.

Create a listing, let’s name it /check/oops, and save this supply code as oops.c:

#embody <linux/kernel.h> 
#embody <linux/module.h> 
#embody <linux/moduleparam.h> 
#embody <linux/init.h> 


static int degree = 0;
static int oopsinit(void)  
   printk("oops init (degree = %d)n",degree);
   // degree: 0->simply load; 1->oops; 2->panic
   swap (degree) 
      case 1:
         printk("triggering oops through BUG()n");
      case 2: 
         printk("forcing a full-on panic()n");
         panic("oops module"); 
   return 0; 

static void oopsexit(void)  
   printk("oops exitn"); 

Create a file in the identical listing referred to as Kbuild to regulate the construct parameters, like this:

 EXTRA_CFLAGS = -Wall -g
 obj-m        = oops.o

Then construct the module as proven beneath.

The -C choice tells make the place to begin searching for Makefiles, thus pointing the construct course of on the proper kernel supply code tree, and the M= setting tells make the place to search out the precise module code to construct on this event.

You need to present the complete, absolute path for M=, so don’t attempt to save typing through the use of ./ (the present listing strikes round throughout the construct course of):

/check/oops$ make -C /the place/you/constructed/the/kernel M=/check/oops
CC [M]  /house/duck/Articles/linuxoops/oops.o
MODPOST /house/duck/Articles/linuxoops/Module.symvers
CC [M]  /house/duck/Articles/linuxoops/oops.mod.o
LD [M]  /house/duck/Articles/linuxoops/oops.ko

You possibly can load and unload the brand new oops.ko kernel module with the parameter degree=0 simply to verify that it really works.

Look in dmesg for a log of the init and exit calls:

/check/oops# insmod oops.ko degree=0
/check/oops# rmmod oops
/check/oops# dmesg
. . .
[12690.998373] oops: loading out-of-tree module taints kernel.
[12690.999113] oops init (degree = 0)
[12704.198814] oops exit

To impress an oops (recoverable) or a panic (will dangle your pc), use degree=1 or degree=2 respectively.

Don’t neglect to avoid wasting all of your work earlier than triggering both situation (you will want to reboot afterwards), and don’t do that on another person’s pc with out formal permission.