Bodha

Study resources for electronics and other subjects

Wed, 18 Oct 2023 18:33:32 +0530

If you are here for a specific subject, click on its name in the ToC to jump directly to it.

Introduction

There is a lack of any list of quality resources to study from for (mainly UG) electronics (ECE et al) students. The subjects are much harder than those of CSE counterparts. This means there are a lot of bad resources masquerading as quality ones and get high views, especially on YT, as they essentially serve as last minute prep for students at 3 AM.

In this post, I’ll try to list quality resources I’ve used or come across during my UG. This is NOT an exhaustive list and only contains a few resources. Diligently studying (which I didn’t do) from the resources will hopefully give you a deeper understanding and put you ahead of average engineering plebs like me.

I will keep updating this to include content I forgot, or found to be helpful.

Sources to avoid

Except standard books, avoid everything like a plague. No, that textbook bearing your university’s name and tailored to syllabus is a scam with sloppy multi-level plagiarism, and is the worst literature to exist on the face of Earth.

Any source which has “GATE” written anywhere, in thumbnail, or in source (like channel) name. They are mostly programming you for an exam instead of teaching you the subject in depth and providing intuition.

YT channels whose content don’t have any depth and go on with a mugging up workflow. Popular examples are Gajendra Purohit, Engineering Funda, etc. Avoid them like plague.

Sources to consult

As a thumb rule, prefer to go for a domain specialist than a single guy who seems to make videos for every subject under the sun. When starting search, try to go for long form content by sources like NPTEL, MIT OCW, college professors, etc. Not all series are good even in them, so you should put effort into finding the good ones according to your taste.

It does not always have to be college lecture series. Popular != bad. There are many good popular channels out there whose contents are remarkable. Example: Ben Eater.

Attend lectures in college if you have good professors. There are always some out there. They are irreplaceable, many times you can just learn the entire thing during lectures itself.

There is no substitute for practicals. Please get involved in as much projects and practical activity as you can, that gives you a working knowledge and insight into things.

General

Mathematics

Khan Academy is a good resource to a major extent. Sometimes content may not be ordered in playlist properly, so try putting some effort to find them. Also, Grant Sanderson worked with KA to make videos on advanced topics like multivariable calculus, before he opened his famous 3B1B channel on YouTube.

Khan Academy is good for the following subjects:

Calculus and differential equations
Linear Algebra
Multivariable Calculus (Vector Calculus)
Probability and Statistics (upto a point)
Sequences and Series (Start with the AP College Calculus BC playlist) (upto a point)

While it may not cover everything (though a major part is covered), what it covers is done in a very good way. Outside of it, you may search on Brilliant (yes), OCW, NPTEL, etc. I’ll add them towards the end of this section. Or you can just read the books, whichever you have.

Fourier is missing, and Laplace is not really explained well (because Fourier isn’t there). But these things you learn during Signals course again (signals playlist has an excellent explanation), with the reason why they were made in the first place, so maybe it’s okay. Laplace and differential equations are encountered even earlier, during the Control Systems course.

Wikipedia is unironically a good resource, especially for stuff like sequences and series.

(I need to find what I used, I’ll update here as and when I remember or get hold of them.)

Probability and Statistics:

zedstatistics
Ms Aerin articles on Medium
Statistics 110: Probability - Prof. Joe Blitzstein, Harvard University
Physical Applications of Stochastic Processes - Prof. V. Balakrishnan, IIT Madras. This is an advanced course if you like the subject.

Edit: A friend suggested Steve Brunton for Fourier series and transform, and Dr. Trefor Bazett for differential equations. Do check them out!

C Programming

If you know programming already, get K&R and enjoy the absolute best content out there.

“K&R” refers to the book “The C Programming Language” by Brian Kernighan and Dennis Ritchie.

If you are new to programming, start by using online platforms which give you tasks to complete, or learn while doing things. After you are able to write a full program with “hello world” or conditionals yourself, install gcc on your computer and make and break things yourself. It’s a good idea to install a Linux distro (I use Debian Testing, just fire and forget). After you are comfortable, go get K&R.

Do NOT use compilers like Turbo C++. If you do, please close this webpage, you cannot be helped.

Control Systems

Control systems - Prof. C.S.Shankar Ram, IIT Madras

This NPTEL playlist is GOLD. Very calm and lucid explanations. You can get the notes from here.

The professor is the book.

Also, learn MATLAB. At this point you may have some programming and scripting knowledge, time for you to employ it in a new domain. Make heavy use of the references/documentation at the MATLAB website. You can also join the Discord server to ask doubts and questions when you are stuck.

Make sure to install the control and symbolic math toolbox! You might get a license from your college for MATLAB.

Digital logic and VLSI

Digital System Design

Digital Circuits and Systems - Prof. S Srinivasan, IIT Madras

This NPTEL playlist is GOLD. Just see the first video if you doubt me. If you study from this, you are going to impose dominance over others who are just coasting, and your path to studying advanced concepts, microprocessors, and VLSI will be a lot easier. Literally a zero to hero path. Diligently study and make notes!

If you want a book, go with Morris Mano, but the video lecture series will be better for the topics it contains.

Also, an extremely good YouTube channel in the practical domain is Ben Eater. Just check it out!

Microprocessors and Microcontrollers

Bharat Acharya has a good introductory videos. Unfortunately, his full courses are paid (though not too costly if you have money to spare). Sometimes you may find the full playlist online, or Bharat Acharya himself may release some of them.

Anyways, here are some extremely good videos to get you up to speed in the subject (choose the relevant ones, or find on his channel for other architectures). These videos are GOLD, don’t miss them!

(Common) Introduction to Microprocessors: English, or Hindi.
8085 architecture: English, or Hindi.
8086 (English): Architecture, Buses and Memory.

After you know the basics of how a microprocessor is described and ISA is read, you’ll be able to broadly understand any processor under the sun!

Practice reading and writing assembly programming. Use simulators like GNUSim8085 or avr_sim instead of bloated IDEs.

Understand how your C programs are translated to assembly. NPTEL has a very good playlist:

C Programming and Assembly Language - Prof. Janakiraman Viraraghavan, IIT Madras

Also, Ben Eater as always is an extremely good practical resource.

Advanced µc / µp, ARM7

Start with introduction by Bharat Acharya. It is an extremely good video and will get you up to speed very quickly.

For full video series, a very good one is Embedded System Design with ARM - Prof. Indranil Sengupta and Prof. Kamalika Datta, IIT Kanpur, covering in sufficient breadth and depth.

Then consult the official documentation by Arm for learning about architecture, programmer’s model, and ISA in general. You should also consult lecture PPTs and articles posted online. I don’t have specific links to the ones I used back in the days, but you can easily find a lot of them with the help of Google.

Here are a few links to helpful manuals and other resources:

Honestly, I didn’t consult any specific book or video lecture series. If you want, there are some books, as well as series on NPTEL which I linked above. Though, you don’t need to see videos or read books to do any kind programming, let alone assembly. ISA can also be understood directly from references (you will be able to do it, I know), but it is understandable to get a curated text. So you can consult any book you like, even the books I told to avoid at the start. It’s just a matter of understanding the reference.

Make sure to learn ISA and assembly instructions and their addressing modes.

Attempt problems on assembly programming, and build up logic on how to use ARM instructions and flags to your advantage and reduce branching. For example, there is an LDRSBGT possible.

Use CPUlator ARMv7 System Simulator which runs completely on browser, instead of bothering around with Keil.

For LPC2148 microcontroller, the following playlist is good to ramp up:

ARM Programming With Embedded C - Vishal Gaikwad

For memory, hazards, cache, virtual memory, etc., the following are some good resources (in no particular order), choose according to your tastes:

VLSI Design

I cannot stress this enough. These resources are GOLD.

Watch the first 14 videos of New Analog Circuit Design (By Prof. Ali Hajimiri, Caltech).
Get Introduction to VLSI Circuits and Systems - John P. Uyemura.

The playlist is just too good, and you will gain a great insight on the semiconductor physics - how transistors and MOSFETs concepts were conceived, and how they work in great detail at a microscopic level. I would say this is mandatory to watch!

The book has extremely good and lucid explanations, while packing a significant amount of content. It teaches you CMOS logic, stick diagrams, manufacturing process, electrical analysis of MOSFETs (though for that you see the playlist) and CMOS logic, RTL, physical design, system design, clocking, and what not. Literally a zero to hero path. If you don’t trust me, see the reviews on Amazon!

And the book is enjoyable, unlike the boring one by Sung-Mo Kang.

If you have time, you can see Digital VLSI System Design - Prof. S. Srinivasan and Dr. S. Ramachandran, IIT Madras.

This is the sequel to the awesome digital circuits course by the same professor (initially), so you know it will be good!

Another good resource on YT is playlists by Prof. Adi Teman, BIU.

Embedded Systems and (RT)OS

A good resource to look at is the Linux kernel :D

The following resources (in nor particular order) are good for ramping up, choose whichever suits you the best:

Hindi: Embedded and Real Time Operating Systems (ERTOS) - 5 Minutes Engineering (fast concept building)
Real-time operating system - Wikipedia, and follow the rabbit hole :P Yes, Wikipedia is good!
CS 377 Spring ‘14: Operating Systems - Sean Barker, UMass
Real Time Operating System - Prof. Rajib Mall, IIT Kharagpur (Speed up the videos to 1.5x or 2x)
Operating Systems - Neso Academy
OS8 - OS- EZCSE

An extremely good book is An Embedded Software Primer - David E. Simon. I stumbled upon its explanation of shared data problem, and scheduling, and I immediately just got it. The book introduces you to embedded systems and RTOS concepts.

For microcontroller like MSP430, I don’t think I should be adding videos at this point :P, you are capable enough, but anyways the following is a good one:

Introduction to Embedded System Design - Prof. Dhananjay V. Gadre (NSUT) and Prof. Badri N Subudhi (IIT Jammu)

Another good book is Embedded Systems Design: A Unified Hardware/Software Introduction - Vahid, Givargis. Though, I have only skimmed through some of it’s introductory chapters. YMMV.

VLSI Testing and Verification

The following books are very good to learn from:

VLSI Test Principles and Architectures - L.T. Wang, C.W. Wu, X. Wen (colloquially known as WWW).
Writing Testbenches: Functional Verification of HDL Models - Janick Bergeron.

An excellent video series on testing is VLSI Testing - Prof. James Chien-Mo Li, NTU. The prof. has also authored a chapter in WWW!

Circuits

Network Theory

Circuits and Systems (By Prof. Ali Hajimiri, Caltech)

While I haven’t seen this one as I stumbled upon it later, I’ve seen Prof. Hajimiri’s other playlist (New Analog Circuit Design), and I can safely say if you want to have a good insight, this is the playlist you need to see.

Neso Acadaemy’s playlist is also good, particularly for quick learning and ramping up, but it can never rival the depth and insight in Prof. Hajimiri’s lectures.

Engineering Circuit Analysis - Hayt, Kemmerly, Durbin is a good textbook with very good explanation. It is thanks to this book that I could learn this subject and survive the exam!

Analog Circuit Design

New Analog Circuit Design (By Prof. Ali Hajimiri, Caltech)

Extremely good playlist! I came across this later during my VLSI studies, but you don’t have to!

This is my weakest subject :P (no surprises, the course is too big, and the content is very high IQ, and COVID pandemic didn’t help).

Signals and Systems

Continuous time

Signals and Systems 2021 - Prof. Andrew Reader

Can’t recommend the above playlist enough. This is GOLD. If you are new or want to solidify your understanding quickly, just stop everything right now and watch it! It’s only 8 videos long. Make notes!

Signals and Systems - Prof. Alan V. Oppenheim - MIT OCW

Yes, this series is by Alan Oppenheim (the author of the de-facto standard book) himself! The lectures are still relevant despite being recorded more than 35 years ago. You gotta increase the speed. Also, the intro music is addictive, and is still stuck in my mind…

If you want to learn in Hindi, NPTEL has a playlist: Signals and Systems - Prof. Kushal K. Shah, IISER Bhopal.

For book, no surprises here, go with Signals and Systems - Oppenheim, Willsky, Young.

Discrete time / DSP

Digital Signal Processing - Prof. S.C. Dutta Roy, IIT Delhi

This NPTEL video series is GOLD, even though it is old resulting in low video resolution. The prof. knows his stuff and his style of teaching is very lucid. Though you will need to increase the speed to something like 1.5x. Hope you enjoy the difference to discrete-time domain!

Digital Signal Processing - Prof. Alan V. Oppenheim - MIT OCW

This is another old series instructed by Oppenheim himself! You gotta increase the speed here too. For some reason, old Signals professors have the tendency to be slow…

Digital Signal Processing - KK Awasthi (Hindi)

This playlist is in Hindi, and is primarily geared towards filter design and DFT. If you want to quickly learn filter structure and realisation, especially if an exam is coming, I would recommend watching it.

For book, go with Discrete-Time Signal Processing - Oppenheim, Schafer, Buck. Please avoid a different book named “Digital Signal Processing” by Oppenhiem.

EM and Communication

Electromagnetic Theory

Prerequisites: Vector calculus. Very important! Didn’t study this subject properly / much :P, but here are some good resources:

Electromagnetic Fields - Prof. Harishankar Ramachandran, IIT Madras

Transmission Lines and EM Waves - Prof. R.K. Shevgaonkar, IIT Bombay

Both the NPTEL playlists are good! It’s up to your tastes to choose any one. The first one is using a blackboard, while the second one uses digital slides and paper + marker.

Prof. Shevgaonkar has also written a book, Electromagnetic Waves - R. K. Shevgaonkar, which you can get.

A good well-known book is Elements of Electromagnetics - Matthew N.O. Sadiku, which is what I was suggested too.

Analog and Digital Communication

Communications Engineering I - Prof. Ali Muqaibel, KFUPM

If you want to quickly learn the subject, this is the playlist you need to see. The prof. explains everything satisfactorily without excessive content. That means the content is good! Though, it does not cover everything you’ll have in your course.

Antenna and Propagation

This is a hard and high IQ subject, but also very interesting. It relates to a major part of our everyday macro world - you’ll start seeing antennas everywhere for the rest of your life once you start learning this subject!

Warning: You must know electromagnetism (like Maxwell’s equations etc), and have a good grasp of vector calculus! Otherwise in your quest to avoid it via integral relations, you’re gonna mess everything up and fail! Yes, that’s very specific :P

Here are some videos I’d suggest watching:

RCAF videos (1960): Propagation, Directivity, and Bandwidth.
USAF videos (1947): Radio Fundamentals - Part 1, Part 2.
Video playlists on the EMViso YouTube channel (by Kathryn Leigh Smith, UNCC + Ansys).
Antenna section of Transmission Lines and EM Waves - Prof. R.K. Shevgaonkar, IIT Bombay. You probably would want to see this as it contains some mathematical derivations.

But mainly, you’re going to learn using book. The subject is just like that, not much video resources outside basics, just literature. The basics of antenna hasn’t (or rather, will not) changed, the subject is mathematics-heavy so you need to read books, there are ton of derivations. Note that you are not going to study the whole book, but a part of it, so size doesn’t matter.

I would suggest Antennas for All Applications - John D. Kraus, Ronald J. Marhefka. There is another book by Constantine A. Balanis considered the de-facto standard text on antenna, but my first impression of it when comparing with Krauss’ text was that it seemed more boring and thicker. YMMV.

There is a “Special Indian Edition” (SIE) of Krauss’ text by McGrawHill (which I read), please try to avoid it. But if book with the above mentioned title is not available, go with the SIE. It’s a sloppy attempt by a random Indian professor (Ahmad S Khan) who wanted to dish out a book with his name, and as a result distorts the text. He added a chapter in between to address a part of university syllabus in India (the change of tone is very apparent), and as a result messes up the latter chapter numbers, and thus he then concatenated chapters.

Fibre Optic Communication

Fiber Optic Communication Technology - Prof. Deepa Venkitesh, IIT Madras

This is a very good series covering the subject in sufficient depth, and gives reasoning behind some things which you normally may ignore. I had binge watched it for multiple days before exams! :P

For book, you may go for Optical Fiber Communications - Gerd Keiser. While I haven’t read it, my friends were positive about it.

Wireless Communication

For book I’ll recommend Wireless Communications: Principles and Practice - Theodore Rappaport. This textbook has very good explanations, and is considered the standard. I’d suggesting reading the book, especially the cellular concept chapter. Many times people just recycle/copy the content from this book. Someone on Wikipedia just straight-up copied 3-4 pages from this book directly!

For videos, I’ll post links to a couple of sources, choose whatever suits you the best.

@LTE4G on YouTube. Good for concept building.
Some LiveOverflow’s videos:
Introduction to Wireless and Cellular Communications - Prof. David KoilPillai, IIT Madras
Fundamentals Of Wireless Communication (Hindi) - Dr.Vivek Bohara, IIIT Delhi
Short Course on Fundamentals of Wireless Communications - David Tse, UC Berkeley - The Qualcomm Institute
Wireless Communication - Prof. Ali Muqaibel, KFUPM
Wireless Communication - Quantum Study Circle. This YT playlist is in Hindi, YMMV w.r.t. content, good for last days preparation.

Networking and Protocols

Computer Networks

Following are some excellent resources:

Networking related videos by Computerphile (GOLD, please watch them!)
But what are Hamming codes? The origin of error correction - 3Blue1Brown. Watch part 2, and Ben Eater’s video, both linked in the description.
Computer Networks - Neso Academy
Playlists by System Engineer YT channel
Hindi: Computer Network (CN) - 5 Minutes Engineering
Relevant Wikipedia articles

You really don’t want to read too much books for this subject. Getting Tanenbaum would be an academic suicide.

A good book which is not thick is Computer Networks - Mayank Dave. It contains lucid and to-the-point explanations and illustrations.

Internet of Things

Ngl, this will seem to be the most useless subject when studying (it isn’t). This subject is essentially 50% bullshitting, 30% learning protocols and models, and 20% thinking about some “smart” thing using Arduino et al (which is 50% bullshit).

This is an easy subject, especially those who are adept with tech and programming like you, so there are no specific resources for this. You should just Google the topic you are studying (say, publish-subscribe model, MQTT, etc.) and see the relevant articles, lecture slides (use stuff like filetype:pdf), or YouTube videos. Searching generically for “IoT” will get you 100% bullshit.

Some YT playlists in Hindi are by Asha Khilrani, which goes into details enough for your exams. Another one is by 5 minutes engineering.

If you are thinking to get a book for this, you can do better. Don’t make the mistake! :P

AI

Artificial Intelligence

Artificial Intelligence - Prof. Patrick H. Winston - MIT OCW

The content in this course is GOLD! The prof. builds the intuition for how things work in an excellent way from the first principles. I would say just watch it!

An Introduction to Artificial Intelligence - Prof. Mausam, IIT Delhi

This is another good course. It also starts with history for those who like dedicated videos on it.

Machine Learning

Introduction to Machine Learning - Prof. Sudeshna Sarkar, IIT Kharagpur

This is a good theoretical course on ML, which (according to one of the comments) follows content from the Machine Learning book by Tom Mitchell. Though due to its heavy theoretical nature and the difficulty, sometimes you might get bored. :P

You can download the presentations used in the course from here.

A fun and GOLD tier resource is the Machine Learning playlist by StatQuest. Josh Starmer explains in a very cool, fun and easy way! Of course, it does not contain the theoretical rigour of the NPTEL playlist, but as an engineering student, you must be familiar about tradeoffs by now. :P

Visually Explained is another good channel, and contains short and intuitive videos for concept building.

Conclusion

That’s it for now! Hope you find these useful! :)

I’ll update this post when I find some other good resources I had come across (i.e. to add missing stuff), to update links, or to clarify something if it isn’t clear.

If you encounter any problems or know of link rot or content being moved or redirected, please comment and let me and everyone else know!

Running keyutils tests

Sat, 14 Oct 2023 02:29:49 +0530

It’s not very apparent how to run the tests in the keyutils repo ( kernel/git/dhowells/keyutils.git - Key management utilities), especially if you don’t work on kernel areas like keyrings and watch queue.

Running tests does require some kernel preparation. Searching on internet fetches you limited information. So I looked further what would cause some failures by looking at the test code.

I was able to run all the test using the following config options enabled (you can paste in a file and then use the merge_config script, see my previous post):

CONFIG_KEYS=y
CONFIG_TMPFS=y
CONFIG_CRYPTO_LIB_CHACHA20POLY1305=y
CONFIG_BIG_KEYS=y
CONFIG_TRUSTED_KEYS=y
CONFIG_SYSTEM_TRUSTED_KEYRING=y
CONFIG_SECONDARY_TRUSTED_KEYRING=y
CONFIG_SYSTEM_BLACKLIST_KEYRING=y
CONFIG_SYSTEM_TRUSTED_KEYS="key.pem"
CONFIG_CRYPTO_DH=y
CONFIG_KEY_DH_OPERATIONS=y
CONFIG_INTEGRITY=y
CONFIG_INTEGRITY_SIGNATURE=y
CONFIG_INTEGRITY_ASYMMETRIC_KEYS=y
CONFIG_INTEGRITY_TRUSTED_KEYRING=y

Note that we specify a key named key.pem to CONFIG_SYSTEM_TRUSTED_KEYS, which causes the key to be added in the trusted keyring during compile time.

We can generate a dummy key for tests using the following command:

$ openssl req -x509 -newkey rsa:4096 -out key.pem -sha256 -nodes -subj "/CN=."

Now build the kernel and boot into it using QEMU.

Install the keyutils packages (on Debian) as follows:

$ sudo apt install keyutils libkeyutils*

Clone the keyutils repo:

$ git clone https://kernel.googlesource.com/pub/scm/linux/kernel/git/dhowells/keyutils.git
$ cd keyutils

Now run tests using make:

$ make test

Now all tests in the tests/ directory will run.

Kernel QEMU setup for development and debugging

Sat, 14 Oct 2023 01:16:38 +0530

Introduction

Setting up kernel for debugging can be a confusing task for a beginner. It certainly was for me when I was starting out.

In this post, I’ll outline a way to quickly set up your computer to compile and run kernels on the fly. You need to never hassle about it again, we will make aliases along the way so that you just have to use simple commands to do things. Tab completion auto-filling the command name makes things very convenient.

Of course, one should know what an alias is doing before adding them for general use in .bash_aliases, so please make sure you understand everything and only then add it. Hopefully, I’ll be clear, and the context will be obvious if I do not mention some things. I assume basic familiarity with the kernel.

For those who have already read the article and just wants to see the bash aliases together, I have them (and a couple more) in the following gist: https://gist.github.com/siddhpant/0af22835e6825b90869f583749af2070

I may update the gist, but not this post necessarily.

Cloning and saving the kernel

If you ever tried to clone the kernel, you’d know the download is huge! The history is long, so it makes sense. But it does not make sense to keep cloning it again and again.

Clone entire history once, then keep updating it (using git pull). Whenever you want to work on the kernel, either

Use git worktree, which copies the tree but shares the .git across all of them. Note that it is the .git folder which is the biggest (currently it is of 2.9 GB).
Copy the entire repo using cp.

Do this for each bug fix or patch set, i.e., for related work. This will help in multitasking and saving work. If you use copy-on-write filesystems like BTRFS, the copy won’t even actually take extra space. Only upon modifications will the affected files be created anew.

While the git.kernel.org (g.k.o) is the canonical home for the kernel, that server is slow for our download. We anyways won’t be pushing upstream directly. So, it’s best to use the googlesource mirror.

Clone the mainline once in a folder named updated_mainline as follows:

$ git clone https://kernel.googlesource.com/pub/scm/linux/kernel/git/torvalds/linux updated_mainline

Now whenever you need to do some work, let’s say work on a UAF in net, you can simply do either of the following:

# Worktree method (inside updated_mainline).
$ git worktree add ../net_uaf
$ cd ../net_uaf

# Copy method.
$ cp -r updated_mainline/ net_uaf
$ git switch -c uaf_fix # Do not work on master branch.

While git worktree should be preferred, I use the copy method, because that’s what I started with :-P.

Setting up git

One must ensure that the git configuration is correctly set for kernel repos, as identity is very crucial for signing your commits and sending them via email.

# Set identity.
$ git config user.name "Your name"
$ git config user.email "your@email.com"

I have GPG signing enabled globally in git, but kernel commits for plebs like us must not be GPG signed, it is used only by maintainers.

GPG signing is done, on say GitHub, to ensure that the git identity is not fake. By adding a public key to GitHub and checking the signatures in commits, GitHub can verify committer identity. But in kernel development, we use mailing list, so we actually do not need GPG signing. The Signed-off-by email and the From: address of the patch email must match.

# Disable GPG signing.
$ git config commit.gpgsign false

Upon pulling, rebase should be done. The upstream is supreme. Also, whenever someone says on mailing list to rebase, you just need to pull.

# Rebase on pull.
$ git config pull.rebase true

Email SMTP details should be set properly, as the patches to the mailing lists are typically sent using git send-email. But please

DO NOT store the password in config. One can utilise keyrings to store the password. Here is an excellent blog post detailing the process: Using git send-email with gnome-keyring – Guillaume Champagne (web archive here).
If possible, make sure to create an application specific password to use for git.

This all then simply results in the following git commands:

# Set up email settings for send-email.
$ git config sendemail.smtpServer "smtp.email.com"
$ git config sendemail.smtpEncryption tls
$ git config sendemail.smtpServerPort 587
$ git config sendemail.smtpUser "your@email.com"
$ git config sendemail.confirm "always"

It’s effectively mandatory to use checkpatch.pl script to check your patches, otherwise you’ll have complaints over the mailing list (outside of genuine cases). Manually doing it is tiring, and one may forget to do it or get tired of it.

Fortunately, git allows for hooks to be executed before and after actions like commit. Whenever someone is annoying you with web3 BS like blockchain with smart contracts, just show them git.

Shuah in the LFD103 course¹ suggests a neat trick to add checkpatch to the post-commit hook. Basically, after committing changes you extract the commit in patch format (using git show) and pass it to checkpatch, which will show whether there are any problems or everything is okay.

To do that, add the following in updated_mainline/.git/hooks/post-commit and make it executable:

#!/bin/bash

patch=$(git show --format=email HEAD)
./scripts/checkpatch.pl --show-types --strict --codespell - <<< "$patch"

kgit_config

We can put everything together in a bash function as follows:

kgit-config() {
 git config user.name "Your name"
 git config user.email "your@email.com"
 git config commit.gpgsign false
 git config pull.rebase true

 git config sendemail.smtpServer "smtp.email.com"
 git config sendemail.smtpEncryption tls
 git config sendemail.smtpServerPort 587
 git config sendemail.smtpUser "your@email.com"
 git config sendemail.confirm "always"

 echo -e '#!/bin/bash

 patch=$(git show --format=email HEAD)
 ./scripts/checkpatch.pl --show-types --strict --codespell - <<< "$patch"
 ' | awk '{$1=$1};1' > .git/hooks/post-commit
 chmod u+x .git/hooks/post-commit
}

Now, you can just use kgit-config on terminal and have everything done for you.

Even though this is a one-time setup (because you use/copy this repo in the end), it’s good to have this alias. You may also work on subsystem-specific trees, linux-next, etc., mainline isn’t the only repo.

Setting up QEMU image

This section is essentially from the syzkaller docs on setting up QEMU². I will be talking about x86-64.

Make a specific folder for storing QEMU related things, like the system image. It’s good to organise things.

$ mkdir -p qemu/image
$ cd qemu/image

We will use the create-image.sh script provided by Google for syzkaller. It will create a Debian image with a passwordless root user, and also generate SSH keys so that we can use SSH to login into the system once run by QEMU.

Download the script as follows:

$ wget https://raw.githubusercontent.com/google/syzkaller/master/tools/create-image.sh
$ chmod +x create-image.sh

You may want to remove the -x flag from line 7 in the script to avoid spam during runtime.

Create a 10 GB image (suffiicient size to install some things later and not worry about space) containing Debian 12 (bookworm) as follows:

$ ./create-image.sh -s 10240 -d bookworm -f full

# Delete leftover chroot folder from building
$ sudo rm -rf chroot

Name the image bookworm.img so you know what it is, and the associated SSH keys similarly. They all reside in the same folder as the script, here that is qemu/image.

Configuring the kernel

One can generate a default config with make defconfig.

Though, generally when debugging bugs, like those listed on syzkaller, you’ll get a config file (which is to be stored as .config in the kernel root). These may not have all the new config options, and during build time it may ask you for the values those options should have. You could just spam (press and hold) the enter key to set the defaults, or use the handy merge_config.sh script as:

$ ./scripts/kconfig/merge_config.sh .config

But this script is for a more powerful purpose. As the name suggests, it merges the config files automatically. It accounts for all dependencies for you, so you do not have to bother with setting values yourself normally.

This allows for a neat way to configure kernel for our QEMU machines because we need to set some more options. It would be tiring to do them by hand, so we can just have the relevant options in a config file somewhere, let’s say in $HOME/linux/config, and then pass it to this script.

For our QEMU machine, need to include the kvm_guest.config from kernel/configs in the repo, as that includes some necessary config options, like enabling virtIO, 9P filesystem, networking, etc.

We need some options like CONFIGFS_FS, SECURITYFS enabled for correctly booting our image. Also, debugging benefits from a couple of other things, like KASAN, UBSAN, preemption, lockup detector, etc. So, we can have a common config as follows, which we will always include.

config common.config


CONFIG_DYNAMIC_DEBUG=y
CONFIG_DEBUG_FS=y
CONFIG_CONFIGFS_FS=y
CONFIG_SECURITYFS=y
CONFIG_DEBUG_INFO=y
CONFIG_KASAN=y
CONFIG_UBSAN=y
CONFIG_PANIC_ON_OOPS=y
CONFIG_PANIC_ON_OOPS_VALUE=1
CONFIG_PANIC_TIMEOUT=0
CONFIG_PREEMPT_BUILD=y
CONFIG_PREEMPT=y
CONFIG_PREEMPT_COUNT=y
CONFIG_PREEMPTION=y
CONFIG_PREEMPT_DYNAMIC=y
CONFIG_SCHED_CORE=y
CONFIG_PREEMPT_RCU=y
CONFIG_PREEMPT_NOTIFIERS=y
CONFIG_LOCKUP_DETECTOR=y
CONFIG_SOFTLOCKUP_DETECTOR=y
CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y
CONFIG_HAVE_HARDLOCKUP_DETECTOR_BUDDY=y
CONFIG_HARDLOCKUP_DETECTOR=y
CONFIG_HARDLOCKUP_DETECTOR_PERF=y
CONFIG_HARDLOCKUP_DETECTOR_COUNTS_HRTIMER=y
CONFIG_HARDLOCKUP_CHECK_TIMESTAMP=y
CONFIG_BOOTPARAM_HARDLOCKUP_PANIC=y
CONFIG_DETECT_HUNG_TASK=y
CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=140
CONFIG_BOOTPARAM_HUNG_TASK_PANIC=y
CONFIG_WQ_WATCHDOG=y
CONFIG_TUN=y
CONFIG_FAULT_INJECTION=y
CONFIG_FAILSLAB=y
CONFIG_FAIL_PAGE_ALLOC=y
CONFIG_FAULT_INJECTION_USERCOPY=y
CONFIG_FAIL_MAKE_REQUEST=y
CONFIG_FAIL_IO_TIMEOUT=y
CONFIG_FAIL_FUTEX=y
CONFIG_FAULT_INJECTION_DEBUG_FS=y

Sometimes we may need more options which are there in kernel/configs/debug.config in the kernel root. Also, we may sometimes want to enable tracing or options like 9P debugging, which can be done by adding the options in another config file as follows:

config tracing.config


CONFIG_KCOV=y
CONFIG_KASAN=y
CONFIG_KASAN_INLINE=y
CONFIG_FTRACE=y
CONFIG_DYNAMIC_FTRACE=y
CONFIG_FUNCTION_TRACER=y
CONFIG_FUNCTION_GRAPH_TRACER=y
CONFIG_IRQSOFF_TRACER=y
CONFIG_PREEMPT_TRACER=y
CONFIG_SCHED_TRACER=y
CONFIG_STACK_TRACER=y
CONFIG_BLK_DEV_IO_TRACE=y
CONFIG_FUNCTION_PROFILER=y
CONFIG_FTRACE_MCOUNT_RECORD=y
CONFIG_NET_9P_DEBUG=y

Now, we can simply create our config as:

$ ./scripts/kconfig/merge_config.sh .config \
 ./kernel/configs/kvm_guest.config \
 $HOME/linux/config/common.config

For the extra debug options, simply add the config files:

$ ./scripts/kconfig/merge_config.sh .config \
 ./kernel/configs/kvm_guest.config \
 ./kernel/configs/debug.config \
 $HOME/linux/config/common.config \
 $HOME/linux/config/tracing.config

kconfig

We can set up a bash function for this as follows:

kconfig() {
 case "$1" in
 "--def")
 make defconfig "${@:5}"
 ./scripts/kconfig/merge_config.sh .config \
 ./kernel/configs/kvm_guest.config \
 $HOME/linux/config/common.config
 ;;

 "--fix")
 ./scripts/kconfig/merge_config.sh .config \
 ./kernel/configs/kvm_guest.config \
 $HOME/linux/config/common.config
 ;;

 "--debug")
 ./scripts/kconfig/merge_config.sh .config \
 ./kernel/configs/kvm_guest.config \
 ./kernel/configs/debug.config \
 $HOME/linux/config/common.config \
 $HOME/linux/config/tracing.config
 ;;

 *)
 echo "Pass --def, --fix, or --debug."
 ;;
 esac
}

Now we can just quickly configure using kconfig command.

My gist has more options, if interested one can check it out.

Building the kernel

The kernel can be built with:

$ make -j`nproc` all

The nproc allows for parallelised building, so that the compile time is significantly improved. Some people suggest to use a number = 1.5*nproc in the argument (like if nproc is 12, use -j18).

Sometimes we may want to build with LLVM. For that we can pass LLVM=1 in the make argument, as follows:

$ make -j`nproc` all LLVM=1

Now, if we use QEMU to run the kernel, it will be successful, but you’ll notice that any loadable modules you may have enabled or made won’t be there, because the loadable .ko files, or even the /lib/modules folder, simply does not exist.

We need to use the modules_install make recipe to copy them to a location, and somehow access it inside the VM. We can achieve that using virtio 9P filesystem. That’s why I had mentioned we need to enable it during the configuration.

Let’s copy the modules to a new folder named .compiled_modules in the tree root. Note that the name starts with a dot, because the .gitignore is configured to ignore most hidden files and folders.

$ make INSTALL_MOD_PATH=./.compiled_modules modules_install

modules_install creates a symlink to the kernel source tree in /lib/modules/<version>/build, but we cannot really access the symlink from inside the VM (as the mount point will be the .compiled_modules folder, and not its parent).

So please delete that symlink. One can copy the entire tree to the build directory, but there is no need to. But it is a good idea to copy the config file, so the config of the currently running kernel is accessible inside the VM.

kmake-all

We can now put everything in a bash function as follows.

kmake-all() {
 (
 set -e

 if [[ -f ".llvm" ]]; then
 echo -e ".llvm found - Using LLVM.\n"
 make -j18 all LLVM=1 "$@"
 else
 echo -e ".llvm not found - Using GCC\n"
 make -j18 all "$@"
 fi

 # Store loadable modules so we can use in QEMU via virtfs.
 # Note: We delete the old folder to avoid failing mkdir et al.
 rm -rf .compiled_modules
 make INSTALL_MOD_PATH=./.compiled_modules modules_install

 # Symlink to local dir in /lib/modules/*/build won't work in
 # the VM, so remove it and just add the config file there.
 rm ./.compiled_modules/lib/modules/*/build
 mkdir $(ls -d ./.compiled_modules/lib/modules/*)/build
 cp .config ./.compiled_modules/lib/modules/*/build
 )
}

Note that we automated the LLVM argument by checking if a file named .llvm exists in the repo root. You can make using touch .llvm. This is done because it is annoying to write LLVM=1 everytime, it’s very convenient to just type km and use tab completion.

Running the kernel in QEMU (you are probably here for this)

The most confusing part most people beginning with kernel development have is running QEMU properly.

QEMU has a lot of arguments listed in its manpage. Naturally, it might look like a daunting task at first to figure it out, but after done once it actually starts making perfect sense.

Explanation of the options we use

Since we are going to emulate an x86-64 system, the program name would be qemu-system-x86_64.

As we are on an x86-64 CPU already, we emulate the same CPU using the -cpu host option.

We enable KVM virtualisation acceleration using -accel kvm, which allows for the near native performance.

We are going to work using the command line, so we disable the graphics with -nographics option.

We can allocate memory to the VM using -m option. For instance, if we want to allocate 4 GB of RAM, we will use -m 4G.

We can allocate the number of cores using the -smp option. This is important, as race conditions will not happen without multicore setup, as you’ll only have one thread running by default (-smp 1). I allocate half the number listed by nproc. For example, -smp 6.

We need to specify the kernel image location using -kernel flag. If in the kernel repo root after building, use -kernel ./arch/x86_64/boot/bzImage.

We can pass command-line parameters for the kernel using the -append option.

console=ttyS0 tells the kernel to dump the logs (same as dmesg) on ttyS0, which is the tty emulated by the QEMU window.
root=/dev/sda tells the root partition of the image is /dev/sda.
earlyprintk=serial tells the kernel to print the early boot messages over the serial port.
nokaslr disables Kernel Address Space Layout Randomization (KASLR) and causes kernel to be loaded in its standard memory location.
net.ifnames=0 tells the kernel to disable the Predictable Network Interface Names mechanism, which is needed if the “Failed to start Raise network interfaces” error is encountered³.
panic_on_oops=1 tells the kernel to panic when there is an oops, but we set this in the kernel config for compilation, so we need not add this.
panic_on_warn=1 tells the kernel to panic when a WARN (or a BUG) is encountered.
panic_on_io_nmi=1 tells the kernel to panic when an IO error causes an NMI.
panic_on_rcu_stall=1 tells the kernel to panic when an RCU stall is encountered.
max_rcu_stall_to_panic=1 tells the kernel to panic even for a single RCU stall.
panic_on_unrecovered_nmi=1 tells the kernel to panic when an unknown/memory NMI is encountered. This is by default off due to hardware vendor reasons, but for QEMU we don’t have that limitation. See kernel docs.⁴
selinux=1 enables the SELinux module. Setting to 0 disables it.

The arguments discussed above can be passed using -append "console=ttyS0 root=/dev/sda earlyprintk=serial nokaslr net.ifnames=0 panic_on_warn=1 panic_on_io_nmi=1 panic_on_rcu_stall=1 max_rcu_stall_to_panic=1 panic_on_unrecovered_nmi=1 selinux=0".

We need to specify the location of our raw format Debian image we created using the -drive option. For example, -drive file=$HOME/linux/qemu/image/bookworm.img,format=raw. Note the lack of space between the two kwargs, it is important so that QEMU parses it correctly as arguments to -drive.

We can set the networking options using -net option.

We need to set SSH settings, as we discussed we allow for SSH login. For our case, we will set them using -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 (config values straight from syzkaller docs², you are free to change them).

We also set the emulated NIC settings using -net nic,model=e1000.

We can store the PID of the QEMU VM using -pidfile option. For example, -pidfile vm.pid.

We also mentioned we access the .compiled_modules inside the VM. We do that by setting a mount point for the 9p virtfs using the -virtfs option.⁵ Specifically, we use the following (remember the lack of space after commas):

-virtfs local,path=./.compiled_modules/lib/modules,mount_tag=compiled_modules,security_model=none

The first argument specifies the filesystem driver. We simply use local so the individual virtual FS functions are translated directly to act on the host filesystem. The path specifies the path of the directory to mount (which in our case is the directory we want to be mounted to /lib/modules in the VM). mount_tag specifies the tag of the mount point inside the VM. The security-model specifies the security model for the files in path (credentials, attributes, etc.). We use none so files created in VM are stored as it is. You can read more on the QEMU docs.⁵

Lastly, we can store all the output by piping the QEMU output to tee command.

The command

Therefore, to run our compiled kernel on QEMU, we use the following command by putting together everything:

$ qemu-system-x86_64 \
 -cpu host \
 -accel kvm \
 -nographic \
 -m 4G \
 -smp 6 \
 -kernel ./arch/x86_64/boot/bzImage \
 -append "console=ttyS0 root=/dev/sda earlyprintk=serial nokaslr net.ifnames=0 panic_on_warn=1 panic_on_io_nmi=1 panic_on_rcu_stall=1 max_rcu_stall_to_panic=1 panic_on_unrecovered_nmi=1 selinux=0" \
 -drive file=$HOME/linux/qemu/image/bookworm.img,format=raw \
 -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 \
 -net nic,model=e1000 \
 -pidfile vm.pid \
 -virtfs local,path=./.compiled_modules/lib/modules,mount_tag=compiled_modules,security_model=none \
2>&1 | tee vm.log

Logging in

The username to login is root if you followed the mentioned procedure to make the image.

To login using SSH, in a new window use the following SSH command (which uses the key we generated):

$ ssh -i $HOME/linux/qemu/image/bookworm.id_rsa -p 10021 -o "StrictHostKeyChecking no" root@localhost

We use port 10021 because that’s what we configured in QEMU.

Terminating

Use Ctrl+A and then X to terminate the VM.

kemulate

We can put everything together, and allow for more user arguments which can override the defaults, in a bash function / aliases as follows:

bash kemulate


kemulate() {
qemu_args=""
# We will pass user args to QEMU, except the flags.
# Since flag processing is needed, we will append them in the end.
# Also, by appending the user args at the end, the default arguments
# can be overriden by user.
user_args="$@"
# Use host for the KVM on terminal.
qemu_args+="-cpu host -accel kvm -nographic"
qemu_args+=" "
# Memory size.
qemu_args+="-m 4G"
qemu_args+=" "
# Number of cores.
qemu_args+="-smp 6"
qemu_args+=" "
# Kernel image location.
qemu_args+="-kernel ./arch/x86_64/boot/bzImage"
qemu_args+=" "
# Kernel command line parameters.
qemu_args+="-append \""
qemu_args+="console=ttyS0 root=/dev/sda earlyprintk=serial nokaslr "
qemu_args+="net.ifnames=0 panic_on_warn=1 panic_on_io_nmi=1 "
qemu_args+="panic_on_rcu_stall=1 max_rcu_stall_to_panic=1 "
qemu_args+="panic_on_unrecovered_nmi=1"
if [[ "$1" == "--selinux" ]]; then
qemu_args+=" selinux=1"
user_args="${user_args:9}"
else
qemu_args+=" selinux=0"
fi
qemu_args+="\" "
# Debian image to boot.
qemu_args+="-drive file=$HOME/linux/qemu/image/bookworm.img,"
qemu_args+="format=raw"
qemu_args+=" "
# User settings for SSH.
qemu_args+="-net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22"
qemu_args+=" "
# NIC settings.
qemu_args+="-net nic,model=e1000"
qemu_args+=" "
# PID file.
qemu_args+="-pidfile vm.pid"
qemu_args+=" "
# Use virtfs to get access to loadable modules inside QEMU.
qemu_args+="-virtfs local,path=./.compiled_modules/lib/modules,"
qemu_args+="mount_tag=compiled_modules,security_model=none"
qemu_args+=" "
# Append the user args.
qemu_args+="$user_args"
# Run QEMU (eval used to avoid bash splitting arguments on spaces)
eval "qemu-system-x86_64 $qemu_args 2>&1 | tee vm.log"
}
alias kemulate-one="kemulate -smp 1"

Now, just use kemulate to run the kernel. You can use kemulate-one if you don’t want multi-core setup. You can use --selinux if you want to enable selinux. You can, as mentioned earlier, add and override the QEMU arguments by passing them to the function.

klogin

Similarly, we can make a bash function for logging in via SSH (and store the output to a file) as follows:

klogin() {
 ssh -i $HOME/linux/qemu/image/bookworm.id_rsa \
 -p 10021 -o "StrictHostKeyChecking no" root@localhost \
 2>&1 | tee ssh_op.log
}

Editing fstab to mount /lib/modules inside the VM image

We booted into the VM, but we still have not mounted the 9P mount point we have created for /lib/modules.

We can use the command line to do it, but doing it everytime is a hassle. So, we just add an entry in /etc/fstab so that it is automatically mounted at boot.

Append the following in /etc/fstab and save:

# <file system> <mount pt> <type> <options> <dump> <pass>
compiled_modules /lib/modules 9p trans=virtio,version=9p2000.L 0 0

Now restart the VM (quit and kemulate again), and see if the folder in /lib/modules exist. If you followed everything correctly till now, it will be there.

Decoding stacktrace

Sometimes you’ll want to decode a stacktrace dumped by the kernel. We can use the decode_stacktrace.sh script in the kernel scripts folder for it.

The following bash function does it for you:

ktrace-decode() {
 if [[ "$1" == "" || "$2" == "" ]]; then
 echo "Provide input and output filenames."
 exit 1
 fi

 (./scripts/decode_stacktrace.sh vmlinux < "$1") > "$2"
}

Use as ktrace-decode in.log out.log.

Many times you can make in.log by appropriately trimming the vm.log file we tee’d QEMU’s output to in our command.

Getting maintainers

You debugged everything and created patches. Now who to send these patches to?

One can use ./scripts/get_maintainer.pl to get the appropriate people and mailing lists to send the patch to.

You can use the script name directly. It is big enough for me to create a simple bash alias, so here it is:

kget-maintainers() {
 ./scripts/get_maintainer.pl "$@"
}

One can extend this into ksend-patch which can parse the get_maintainer.pl output and appropriately sets the to and cc arguments for git send-email.

That’s it for now. Hope you found this useful!

Migrated some content

Thu, 12 Oct 2023 21:16:27 +0530

Initial migration of select content from other sources is complete.

Any posts before (below) this one are answers or posts I wrote on Quora. The DRM and KUnit intro is from my vain GSoC proposal (should have put more effort).

I’ve tried to correct any typos, fix up broken sentences and missing references, etc. without changing the content much. Still, I’m sorry if there are any citation etc. issues in the content, good referencing wasn’t something on the top of the mind for the teenage Quora user.

Note: I’m no longer on Quora, the platform has gone down the drain. Before deleting my account, I requested all my data.

About

Sat, 27 May 2023 20:07:10 +0530

Hi there!

I’m Siddh, and this is my personal blog where I will write randomly about random stuff. Views are my own, and does not necessarily reflect that of anyone else.

Find or contact me at: GitHub • GitLab • Email • Matrix • OFTC (siddh)

What does “bodha” mean?

Bodha (बोध) is a Sanskrit word which can mean idea, thought, understanding, knowing, perception, conciousness, intelligence, reflection, etc. (you get the point). Check out the dictionaries here: learnsanskrit.cc, Ambuda.

Hence, this is a cool name for this blog. I will post here whenever I learn something new or share my thoughts.

License

The contents and posts in this blog are licensed under a Creative Commons Attribution-ShareAlike 4.0 International License, unless otherwise stated.

The full text of the license can also be accessed in the content repo.

Sources

Content repo: https://github.com/siddhpant/bodha/ (CC-BY-SA 4.0)
Theme (fork): https://github.com/siddhpant/hugo-theme-terminal/ (MIT)
Website root: https://github.com/siddhpant/siddhpant.github.io/ (AGPLv3)

Credits

Search

Sat, 27 May 2023 20:07:10 +0530

Under Construction

I’m not a web dev, and so I need to take out time and find a good solution for search which does not force me to do too many changes.

And I want to avoid installing the following npm hell:

High level introduction to KUnit

Tue, 04 Apr 2023 00:00:00 +0000

KUnit is a unit testing framework for the Linux kernel. It is inspired by other x-unit testing frameworks (JUnit, Python unittest). According to Brendan Higgins (the author of KUnit) at LPC2019, the need for yet another framework is because other frameworks have their own style and conventions, which does not match kernel conventions. Since the kernel community is huge and telling everyone to change their conventions is a laborious idea, KUnit was made specifically to cater to kernel standards and usage.

Further, quoting Brendan again:

Tests are also documentation. Documentation gets stale. Tests don’t. Tests show how code behaves.

~ Brendan Higgins in an LF Mentorship session.

So unit testing also provides a degree of documentation, by documenting how a unit behaves and what are its interfaces.

KUnit works by running tests when the kernel is run. The tests are compiled into the kernel binary, and the kernel basically self-tests itself on boot. The test results are reported in dmesg logs in a format known as Kernel Test Anything Protocol (KTAP).

While KTAP is sorta human readable, it is not pretty for our eyes. The kunit_tool Python script (tools/testing/kunit/kunit.py) can be used to parse KTAP outputs into a nice colour-formatted text on a terminal. kunit_tool can handle building the kernel, running the tests, and reporting the results all in one go automatically, so it is a very handy tool. Unfortunately, it does not support gcc-7 and higher, one has to use gcc-6 or llvm.

Tests in KUnit are written as a function known as test case. Each test case has several “expectations” and “assertions” on how the code should behave. These expectations are nothing but macros like KUNIT_EXPECT_EQ, KUNIT_EXPECT_NULL, KUNIT_ASSERT_EQ, etc. The difference between an ASSERT and an EXPECT is that the former will stop the test case when it fails, while the latter does not. The result will be a fail in both cases though. The documentation consists of various simple examples, such as below (comments are mine):

/*
 * Test basics of an add() function.
 *
 * struct kunit represents instance of a test.
 * It is defined in /include/kunit/test.h.
 */
void add_test_basic(struct kunit *test)
{
 /*
 * Testing 1 + 0 = 1.
 * Expected output = 1.
 * Function call to test = add(1, 0).
 *
 * KUNIT_EXPECT_EQ checks if both are equal.
 * Order does not matter here.
 */
 KUNIT_EXPECT_EQ(test, 1, add(1, 0));

 /* Testing 1 + 1 = 2 similarly. */
 KUNIT_EXPECT_EQ(test, 2, add(1, 1));
}

The structure of KUnit’s test collection is referred to as a test suite. It contains the following:

name: The name of the test suite.
test_cases: An array of struct kunit_case, which encapsulates the test cases.
init: Setup/ctor function to run before every test case.
exit: Teardown/dtor function to run after every test case.
suite_init: Setup/ctor function for the test suite (gets executed first).
suite_exit: Teardown/dtor function for the test suite (gets executed last).

The test files are meant to be housed alongside the code it tests, or in a folder named tests. The convention for the test files in DRM core seems to be tests/<name>_test.c.

High level introduction to DRM subsystem

Mon, 03 Apr 2023 00:00:00 +0000

About DRM subsystem

Direct Rendering Manager is very central from the point of view of usability — it is the subsystem responsible for showing what is on our screen, including this post. As such, it is directly responsible for enabling the wide adoption of Linux distros, and is what the user is visibly impacted by.

The DRM subsystem is populated largely by display drivers mainly maintained by the companies who make GPUs. The drivers/gpu/drm directory consisting of various drivers for various vendors and devices can be seen on nautilus as below:

Thus, in order to incorporate drivers for different hardware in the kernel, we can’t have driver authors churn out duplicate code for the same thing, and want a standardised hardware-independent interface to make lives easier and to have the codebase maintainable. This is fulfilled by the core of the DRM subsystem (“DRM core” henceforth) — the drivers are then left to manage the hardware-specific nitty-gritties and features.

DRM core basics - what and why

The DRM subsystem is responsible for the management of GPUs from kernelspace and interfacing them with userspace. It handles all the hardware resources, and allows for multiple programs to use the hardware unlike a giant superuser application providing an indirect interfacing (X server). DRM handles memory management, interrupt handlers, switching between GPUs (like between dGPU and iGPU), mode-setting, and rendering composition of frames.

A mode is a set of display properties like resolution, color depth, refresh rate, etc. A part of the DRM subsystem known as Kernel Mode Setting (KMS) is responsible for setting the mode and rendering frames on the screen. The working can be boiled down to the following:

The pixels to render are stored as frames in GPU’s memory buffers known as framebuffers. DRM provides an abstraction to manage these framebuffers. A framebuffer is managed using a “plane”, which handles cropping and scaling of the frames (so that we have scrolling and zooming).

A screen may have multiple elements, and we might need to overlay frames on top of other frames (instead of redrawing everything). A good example is the mouse pointer. Thus, we need composition, as well as generate the data to send to the monitor for rendering. This is handled in hardware by scanout buffers. In DRM lingo, they are (unfortunately in my opinion) known as CRTC — from CRT (Cathode Ray Tube) Controller. It is not related to controlling the magnetic fields in a typical CRT setup. This misleading term is a holdover from the old days when monitors were on CRT technology.

The DRM CRTC abstraction allows for blending / composition of several planes, and outputs the frame which needs to be rendered on the screen. A chunk of modesetting is done in this part — from screen resolution to refresh rate. This is hence a central part of DRM subsystem, as this is responsible for what is finally shown on the screen.

The scanout signals generated by CRTC then needs to travel to the screen over the PHY (the physical interface / wire connecting the GPU to screen). But the PHY’s interface (the “connector” such as VGA, HDMI, etc.) may require the signal in a certain format. Thus, we need to encode the output from the CRTC before giving it to the connector. This is handled by the appropriately named “encoder”. This also allows for abstraction of the PHY — CRTC code does not need to worry about the where and how the signal will travel.

Schematically, the KMS display pipeline can be shown as follows (courtesy kernel docs):

Originally, this needed several different commands to the kernel. This implies going through several different states (the states increase combinatorically with the number of commands). If we try to do an invalid setting, we will come to know of its invalidation only at the point the actual invalid command is sent. This can be after a chunk of setup being done already and rolling back may be impossible. This also yeilds visible “tearing” — the next frame may not have been rendered properly as refresh rate / VBLANK (time between rendering the last visible line of a frame and the first visible line of the next frame) synchronisation is not guaranteed. Composite frames may render layer-by-layer instead of together (i.e, no “perfect” frame).

“Atomic mode-setting” allows for giving a configuration and having it verified by the driver. If the configuration requested by the program is invalid, the driver lets it know and does not do any changes. Only if the configuration is valid does the driver do any hardware operations. It also allows for perfect frame — allows for queuing multiple configurations and renders them together at the next VBLANK clock cycle.

According to Theirry Redding at FOSDEM 2015, the interface parameters of stuff like CRTC, planes, etc. are converted to properties of an object. The whole state of hardware is thus encapsulated in atomic state objects. Whenever we want to modify something, we modify the properties of these atomic state objects instead of issuing the command to the hardware directly.

This way, we can pile up several modifications into one object, and issue the final resultant modification to the hardware. Also, after modification the atomic object is checked whether its configuration is valid or not. If it is valid, only then the configuration is applied to the hardware at the next VBLANK clock cycle. Thus, drivers also don’t need to worry about synchronisation.

Need for tests

Naturally, the DRM subsystem (like any other kernel subsystem) is huge. While the code is written and maintained by trustable and qualified kernel developers, such a huge codebase can benefit from hard statistics about its reliability by means of tests, as well as the architectural and behavioural documentation provided by having tests.

DRM core is, as discussed, a crucial piece of infrastructure, and thus one would expect it to be reliably tested given the importance of enforcing standardisation upon competitive and fragmented market forces. Unfortunately, the core is largely untested, as can be seen in the following coverage report obtained using KUnit:

It is a general consensus in the community that this needs to change, and thus more tests need to be written. Due to the nature of DRM susbsystem, and kernel code in general, unit testing is a good way to go, and already has good support by way of KUnit, which I introduce in the next post.

Why don't they just make CPUs bigger and add more transistors so we can have 10 GHz?

Fri, 02 Sep 2022 00:00:00 +0000

Because they don’t work on magic. Some points are as below:

It is very hard to build larger chips while maintaining good yeild, i.e., having less defects. When you scale your design up, with more transistors, interconnects, etc., the probability of defects increases. And since the entire chip has to work, your yeild is less as your chip is larger and you can’t discard a part of it, so you discard it all.
Higher clock frequency will cause more power dissipation, so your chip heats up more, and your electricity bill shoots up.
With so many transistors working, power dissipation will increase massively!
Power dissipation is the main reason — you will fry your chip! Dissipating heat from dense pockets in the chips is very challenging.
With so many transistors, your capacitance will increase as every transistor has an associated gate capacitance, causing an increase in rise and fall times if the circuits aren’t modular enough.
If you want faster circuit, you should increase transistor size for a given load capacitance. But increasing size also increases capacitance, so you would need to reduce the transistor count.
But the capacitance increases due to interconnects now far overshadow that of transistor, and dominates. And you cannot not have interconnects!
It would be very hard to distribute the 10 GHz clock in the circuit, and routing in general, especially when you are adding more transistors.
Digital logic operating at 10 GHz would need to switch the states at that speed, which is hard to make.

The curious mouse click

Fri, 26 Aug 2022 00:00:00 +0000

A fine 45°C May afternoon, with no one to disturb in a room with ceiling fan at full speed and a window AC, was the perfect opportunity for me to study for my upcoming offline end-semester examinations with books on the table at the window. Of course, after studying for quite some time, a break is needed, and I probably took a short break of just 3 hours.

While goofing off on the internet, I came across the Linux Kernel Mentorship Program (LKMP), which is described¹ as:

The Linux Kernel Mentorship Program offers a structured remote learning opportunity to aspiring Linux Kernel developers. Experienced Linux Kernel developers and maintainers mentor volunteer mentees and help them become contributors to the Linux Kernel.

Being a long time Linux user, this seemed like a good opportunity to work on something which I use everyday, coupled with my affinity towards low-level side of things which I wanted to explore and work on. So I decided to at least take a look at the registration process, as the looming threat of an academic massacre² in the June exam was preventing me from freely thinking about applying.

The first thing to do was to register on the LFX platform³, which was not exclusive to LKMP and had a multitude of mentorship programs (touching various fields) being hosted there. After making a profile on the platform by filling suspiciously⁴ detailed fields, and searching for what I was looking for, I came across Linux Kernel Bug Fixing Summer 2022⁵, which had this noticeably big button:

I thought “let’s see how the confirmation page looks like”, and I aimlessly clicked it…

And it immediately enrolled me. Nothing asked — it just directly led me to the screening tasks.

Now that I was into it by my own choice, there is no going back. The screening tasks needed to be completed in a week or so, as the applications were closing on the 18th (maybe I should have goofed off more often).

The screening tasks themselves were a good opportunity to learn things, doing which I learnt about the basics of kernel development. Completing the LFD103⁶ course was also a task, and almost all the other tasks were actually related to what I learnt from the online course. I compiled the Linux kernel for the first time on my own machine and booted into it natively, a small step in the journey, yet a very significant one. After some experimenting, I quickly realised I can’t keep rebooting every time I make changes to the kernel (also secure boot needs to be turned off), so I came across QEMU and KVM, which is very convenient.

QEMU⁷ is a virtualiser and emulator, which can emulate many different CPU architecture and topologies. Using hypervisors, it can emulate the instructions of the virtual machines directly, which yields a performance close to your hardware. If you know about Oracle’s VirtualBox, you can think QEMU as a faster, better, more configurable, more extensive version of it. QEMU literally pwns VirtualBox. You can run a virtual machine with full-blown OS with the userspace UI and everything, or you can just boot into a minimal configuration using the terminal, which is exactly what you want for kernel development.

Towards the end of May, I got selected as a mentee⁸ in the program along with 12 others. The mentors were Shuah Khan, an experienced kernel developer, maintainer, and contributor; and Pavel Skripkin, who is also experienced with the kernel and its internals. Shuah maintains Kernel Selftest (kselftest), USB over IP, and cpupower tools, and is a veteran. Pavel has also contributed to other kernel related projects like smatch and syzkaller.

I was free to choose any bug I wanted to work upon. But before that, some specific prerequisite knowledge needs to be there, and thus there were initial tasks around learning kernel event tracing⁹, dynamic program analysis, fuzzing, etc.

It is useful to know, during runtime, what is happening and executing, which route did the kernel take, what events are triggered, etc. Thus, tracing the events is a good way to debug bugs, as one can see what is happening when the bug gets triggered. Many different event tracers are available, and function_graph is particularly helpful as it shows the call stack in a structured way, showing which kernel functions are executed, along with any context switches which happen. A small sample is:

 1) ! 611.961 us | hci_uart_tty_open();
1) | hci_uart_tty_ioctl() {
1) | hci_alloc_dev_priv() {
1) 2.832 us | hci_cmd_sync_init();
1) 8.267 us | hci_request_setup();
1) + 15.134 us | hci_init_sysfs();
1) ! 164.203 us | }
1) | hci_register_dev() {
0) | hci_uart_tty_open() {

Analysis is needed for detecting bugs. Bugs are of a serious concern as they introduce unintended consequences, like program crash, security issues, reducing the quality of code/program, etc. Hunting bugs at a later stage tends to be more costly as some other person has to have a good look at everything again.

Thus, we should try to find and squash bugs as much as possible before releasing the program to the users. Analysis of program help us in doing that. Broadly, there are two ways employed for analysing the behaviour of programs:

Static analysis, wherein we analyse the program’s code (usually source code, but one can do analysis of machine code too) and look out for bugs. For instance, a hard-coded out-of-bound bug can be detected using static analysis. The analysis is thus consequently done on properties which will hold for all executions of the program.
Dynamic analysis, wherein we analyse the program’s execution when it is running. For instance, we may have an out-of-bound bug due to dynamic access. That can be easily detected using dynamic analysis compared to static analysis. The analysis is thus consequently done on properties which holds just for that single run of program.

The analysis of bugs and their subsequent reporting can be classified into two types:

True positive: The bug report is correct, i.e., the behaviour is indeed a bug.
False positive: The bug report is incorrect, i.e., the behaviour is not a bug and is intended. These are the type-1 errors in statistical parlance. (Thus, type-2 errors are just the undetected bugs.)

From basic statistical and/or practical engineering knowledge, we can infer there must be a trade-off, especially in static analysis, between increasing the number of true positive reports and reducing the number of false positive reports.

With dynamic analysis, we catch unintended behaviour (like use-after-free or out-of-bound access) at runtime, and hence we are typically getting no (i.e., zero) false positives. The trade-off comes into play with the fact that these bugs must be triggered during execution in order to detect them. Untriggered bugs are not detected, and thus code coverage is an important metric.

It has consequently been observed that:

Static analysis may report comparatively more true positives, but they will also report a number of false positives.
Dynamic analysis may report comparatively lesser true positives, but will report less false positives.

Analysis can be run in user-space or in kernel-space. Linux kernel allows us to run debugging in kernel-space. Compilers like clang and gcc, and tools like coccinelle¹⁰ allow for the static analysis of the codebase. Tools like KASAN¹¹, syzkaller¹², etc. help in dynamic analysis of the kernel at runtime.

Also, there is the superiorest technique of adding print (pr_info) statements, though they should be added judiciously as sometimes they may interfere in the racing if one is examining race conditions.

In addition to off-the-record conversations with mentors and the mentee peer group, there were also bi-weekly Zoom meetings with Shuah and Pavel, which were very helpful, and helped in learning a lot and solving some doubts. Having a peer group or/and someone to guide is valuable, whoever they may be, since it steers/motivates us in the right direction.

Linux kernel development happens over email (you can see archives online¹³), and not something like GitHub or GitLab¹⁴. One might think it is because the kernel predates these services (which is true) but should now “upgrade” to newer technologies. But one must keep in mind the sheer volume and size of the kernel: thousands of contributors are there, the kernel has more than 1.1 lakh commits, and all of this must be accessible with least friction. Email is a ubiquitous protocol, and not a locked-in service by some specific company, and thus it provides the least barrier to jump into sending patches (Signing up to see? What’s that?). The alternatives doesn’t scale for the sheer size of kernel contributions, and mostly can’t be accessed offline. Email also helps in decentralization like git.

The syzkaller dashboard¹⁵ is the place (along with the syzkaller-bugs mailing list) where we can find bugs reported by syzbot after fuzzing the Linux kernel. If you want to find bugs to fix, this currently should be your go-to-place to find some.

Syzbot reports bugs and provides the kernel config and a reproducer which triggered the bug, so you can reproduce the bug locally on your machine. It also provides helpful patch testing facility by email, which you can use to verify if your fix works for the bot too.

I had looked at and touched a number of subsystems during the course of my mentorship. The internals of Linux kernel was explored in the process. Of course, initially it was overwhelming (since I had never done this), but over time I learnt how to go about looking at the right places. As the debugging skills improved, I gained more confidence into fixing a bug and eventually sent patches upstream, fixing bugs reported by syzbot and static analysers.

I fixed bugs related to things like race conditions (use-after-free and null-pointer dereference), logical problems causing warnings to be triggered, things pointed out by static analysis tools and docs.

As of 26th August, I have 6 patches accepted, some are waiting for review, and some have been rejected. I have also contributed to the stable kernel (i.e. patch gets backported to the “stable” LTS kernel). The code review on mailing list is direct and to-the-point, and people are very helpful and don’t differentiate whether you are a beginner or not.

You can search for me in kernel git on https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/log/?qt=grep&q=Siddh+Raman+Pant, and can find my mailing list activity on https://lore.kernel.org/all/?q=Siddh+Raman+Pant.

Three months ago, I never imagined I would be able to do this. It has been a very good learning experience! That one aimlessly curious mouse click resulted in a rabbit hole.

The point¹⁶ of this post is to encourage the reader to contribute to the Linux kernel.

We use the kernel everyday, in various forms you might even be unaware of, and the kernel comes for free, as in free lunch, so why not contribute back upstream, whatever the little we can? I’m certainly not telling to sell your soul for this, even just observing the working helps. This is the sort of thing where you can learn a lot of interdisciplinary things whatever your field be, and your work will actually have an impact!

When you will update and use Linux, code I have contributed will also run on your computer and devices!

Isn’t that cool™? If it is, what are you waiting for?

I am migrating select content from my Quora account to this blog. This post is part of the same migration, with some minimal changes done. Also, this same post was also posted by me on LinkedIn.

I also spoke about my mentorship on LFXMS 2023. Slides can be downloaded from https://siddh.me/from_clueless_to_confident.pdf. Let me know your thoughts in the comment section below!

https://wiki.linuxfoundation.org/lkmp ↩︎
92% of class failed in a mid-sem after colleges re-opened, truly an online student moment. Though, it arguably was the hardest semester, with some of the hardest yet very interesting core subjects. ↩︎
https://mentorship.lfx.linuxfoundation.org/ ↩︎
The details are probably used for application to the programs, as evident by the one-click application I experienced. ↩︎
https://mentorship.lfx.linuxfoundation.org/project/8bdac7b8-403f-489d-8999-ed16bca09cd2 ↩︎
https://trainingportal.linuxfoundation.org/learn/course/a-beginners-guide-to-linux-kernel-development-lfd103/course-introduction/course-information ↩︎
https://www.qemu.org ↩︎
For the period of June start to August end. ↩︎
https://www.kernel.org/doc/html/latest/trace/events.html ↩︎
https://www.kernel.org/doc/html/latest/dev-tools/coccinelle.html ↩︎
https://www.kernel.org/doc/html/latest/dev-tools/kasan.html ↩︎
https://github.com/google/syzkaller ↩︎
https://lore.kernel.org/ ↩︎
Current email ecosystem also comes with its own problems (like patch series/conversation management), so subsystems like DRI are moving towards self-hosted GitLab instances (since GitLab has an open-sourced version unlike GitHub). ↩︎
https://syzkaller.appspot.com/upstream ↩︎
Also written because I want to put this out somewhere while it is fresh on my mind. ↩︎

What is the difference between Hindi spelled हिन्दी and हिंदी?

Sat, 05 Mar 2022 00:00:00 +0000

The former is the correct spelling. The dot (अनुस्वार) in latter is a lazy way of writing first. Ignore any X language vs Y language arguments, since you write languages in a script, and both X and Y are using the same script.

The last letter of each varga (ङ, ञ, ण, न, म) is a nasal letter. Only that letter is a valid transcription of the nasal sound which comes before any letter of the same varga. It takes the least distance travelled by the tongue to pronounce those sounds, and you do that too, you just never knew about it.

The dot is just a placeholder for all nasal sounds and is extremely contextual. Even more now when there is now an implicit n/m contextual heuristics applied by people.

Another example: गंगा is a corrupted transcription. गङ्गा is the exactly correct form. Now notice when you pronounce it and compare it to the pronunciation of हिन्दी. Pay attention to how you are making the nasal sound.

Thus, using the dot everywhere mindlessly is loss of information for a phonetic script like Devanagari. It’s not a mere shortcut. The whole damn point of all Indian scripts is to be exact, in a “what you see is what you pronounce" fashion (WYSIWYP :-P).

The conversion of dot to the letter is even given a specific name. It’s called परसवर्ण सन्धि. While I haven’t studied लघुसिद्धान्तकौमुदि, the relevant sutra can be found here: अनुस्वारस्य ययि परसवर्णः.

The dot should be used only in case of ending म् in word, or in cases like succeeding स (or anything in that varga, or basically those without the last nasal letter).

The corruption is first by people initially, then exacerbated by shitty policy of Government of India, but now due to technological laziness and ignorance by American companies like Google and Facebook. Facebook is so lazy that it just defaults to adding a halant instead of making proper conjuncts. And why should they improve? They’re Americans first. They just want to be legible enough for their products to be used by people.

And this is normalising, because Indians (or aptly called endians) are retarded, and are unable to read in their scripts and use their phones in their own languages. Then endians depend on transliteration tools and want to default to sloppy latin script and expect programs to convert it into native script, but are happy with inexact output (even the use of chandrabindu ( ँ ) is reducing because gboard doesn’t add it and defaults to… अनुस्वार, aka the dot). This then also creates a disincentive to create a better native keyboard, and this cycle propagates. FWIW, the tools like gboard are damn good roughly (yours truly also uses it) when compared to shitty keyboard designs of Devanagari, which then again fuels the cycle.

At least people should use something like m17n’s mostly convenient implementation of ITRANS (on Linux), but then people don’t want to learn anything.

How did people count before the invention of the number 0?

Sun, 27 Dec 2020 00:00:00 +0000

You don’t need zero to count quantities. Zero is the “nothing” value’s symbol.

You just go about naming every number, like one, two, three, etc., and there’s no limit to it. This is how it used to be in India, which is unsurprisingly the land where the modern placeholder number system was invented.

Here’s a small note on the numbering system, given in Sri Desiraju Hanumanta Rao’s translation of Sarga 38, Kishkindha Kanda, Valmiki Ramayana:¹

In the Indian counting system hundred thousands becomes one lakh (1,00,000), one hundred lakhs become one crore (1,00,00,000). The ancient Indian legionaries have names like

आयुत (aayuta) = ten thousand per unit
शङ्कु (shanku) = one lakh crores, i.e., a trillion - 10¹²
अर्बुद (arbuda) = 1000 × शङ्कु
मध्यम (madhyama) = 10 × अर्बुद
अन्तम् (antam) = 10 × मध्यम
समुद्र (samudra) = 20 × अन्त्य
परार्ध (paraardha) = 30 × समुद्र

Rama Tilaka says that by giving these numbers it is to be understood that ‘innumerable vaanaras are coming…’ But others hold the view that the ancients have organised military pattern hence particular nomenclature is given to each, apart from the generalisation of Rama Tilaka.

Govindaraja takes up the enumeration as given in Indian Astrology, which multiplies ten times each, as said in verse:

एकम् दश शतम् अस्मात् सहस्रम् अयुतम् ततः परम् लक्षम् ।
प्रयुतम् कोटिम् अथ अर्बुदम् वृन्दे खर्वम् निखर्वम् च ।
तस्मात् महा सरोजम् शन्कुम् सरिताम् पतिम् त्वत् अन्तम् ।
मध्यम् पराधम् आरूह्य अथ उत्तरम् दश गुणम् तथा ज्ञेयम् ॥

‘one, ten, hundred, thousand, ten thousand, one lakh, प्रयुतम् (prayutam), ten lakhs or a million, then a crore and then an अर्बुद (arbuda) ten-crore or a billion, and then ten arbuda-s makes one बृन्द (bRnda) and ten brinda-s make one खर्व (kharva) and ten kharva-s make one निखर्व (nikharva) and ten nikharva-s make one महा पद्म (mahaa padma) and ten mahaa padma-s make one शङ्कु (shanku), one lakh crores or a trillion, and ten shanku-s make one समुद्र (samudra) and then ten samudra-s make one अन्त (anta) and ten anta-s make a मध्यम (madhyama) and ten madhyama-s make one परार्ध (paraardha) it may be known thus…

By this, the nomenclature of million, billion and trillion was there in ancient days and this may be observed by the names: प्रयुतम् : ‘a million…’, अर्बुद : ‘a billion..’, and शङ्कु : ‘a trillion…’, and this exactly relates to the decimal system which is based on the number ten, in which the smaller units are related to the principal units as powers of ten (units, tens, hundreds, thousands, etc.).

Don’t mistake this as just having words for the powers of ten. In Sanskrit (and other Indian languages, but we’re talking about ancient times here) one can make up a word for any number by following certain rules and compounding words.

This way you essentially have a number system without numbers.

Valmiki Ramayana - Kishkindha Kanda - Sarga 38 - Verse 30 ↩︎

How is the site WhiteHat Jr. for teaching coding for children?

Fri, 02 Oct 2020 00:00:00 +0000

This post is a part of migration of my content from Quora. This answer quickly amassed 1k+ upvotes (not common for a no-name user like me) and a lot of interesting comments, in probably less than a week. After that, it was shadow-collapsed by Quora (for no mentioned reason, indicating potential mass reporting), and I didn’t even know that for quite a lot of months. An email appeal to reinstate the answer was successful, but it was too late at that point.

TL;DR: WhiteHatJr fools people with buzzwords and mines & profiles every shred of their kids’ (and probably parents’ too) data.

I will use Wayback Machine links for references so as to save the snapshot incase they change the website.

I will also use mobile screenshots instead of a desktop so as to make them more readable for mobile users.

Let’s start with a cursory look at their homepage.¹

1:1 online coding classes.

Does that mean every child gets personal attention? The teacher’s seemingly stock photo there makes me think they want that to imply.

*Last 19 Spots Left

We all know this strategy, needs no introduction. Also, it seems like their coders, or the program they coded doesn’t know the rules of grammar.

Lots of buzzwords sprinkled here and there. Silicon valley, Google, Waymo, and what not. I doubt a kid who doesn’t know what is 23² would be able to handle the heavy data and statistics used in machine learning at Waymo offices.

Also, more than 3 lakh reviews by students. Earlier they said there was 1:1 teaching. Did they handle more than 3 lakh personal 1:1 education sessions (since students can review each class and educator)? Lmfao.

Okay you might say let’s cut some slack since the company is fairly recent. So we can assume they have atleast 10% the number of educators. 30k teachers, is it? Apparently, they have 7k teachers. If every educator made the kid capable for a job involving stuff with driverless cars, they are either very supreme beings who decided to stay underground for years and then suddenly come together to work for this company, or the claim is fake.

The homepage consists of more buzzwords (including a claim about 1 million+ students (1M == 10L) being associated. Adds a cherry to the 1:1 claim) and extolling about their teachers. One particular thing I would like to point out is their age and price requirements:

Huh a class 1 student who generally doesn’t know trigonometry will code for space missions. Just for a nominal price of ₹1L. I guess all our schools and colleges are soon going to be obsolete. Finally! Thanks, whitehatjr! /s

Before proceeding, let us take a quick look at the detailed curriculum of their ₹99,999 (or I should say ₹1,07,999) plan for grade 1.²

They don’t even use the Indian numbering system, so much for educating India’s kids.

Woah! So advanced syllabus!

Jokes and sarcasm aside, I don’t even need to go into that “syllabus” to point out it’s total scam in the name of “AI/ML” (like almost always). Most of it seems like drag and drop stuff branded like AI/ML.

Let’s cut some slack considering its class 1, let’s look at class 10+ curriculum.³

BRUH MOMENT. You are paying ONE LAKH RUPEES for this, which is just school education. Why do I say this? Here’s why:

Hmm cool, let’s look at the juicy things I’m gonna learn for building the next Google! Aatmanirbhar Bharat, here I come!

For teaching AI/ML to you, they will first teach you what are variables, if else conditionals, loops, and functions.
Then they will teach you graphs and Pandas “dataframes” and numpy “arrays”. Without any knowledge of what’s happening and how their data is actually fed or manipulated!
AFTER teaching you numpy and cooldude hackerman data science stuff, they will teach you the basic building blocks, viz., strings, list, tuples, and dictionaries!
Then you’ll study some basic statistics taught in class 12. Remember, after graphs, plots, Panda dataframes, and numpy!

So much bluffing. Similar goes for the tasks on the right.

Some more class 12 statistics and CS stuff. The major bluff here is about “XGBoost”. The arxiv print⁴ (submitted on 2016) has the following abstract:

Tree boosting is a highly effective and widely used machine learning method. In this paper, we describe a scalable end-to-end tree boosting system called XGBoost, which is used widely by data scientists to achieve state-of-the-art results on many machine learning challenges. We propose a novel sparsity-aware algorithm for sparse data and weighted quantile sketch for approximate tree learning. More importantly, we provide insights on cache access patterns, data compression and sharding to build a scalable tree boosting system. By combining these insights, XGBoost scales beyond billions of examples using far fewer resources than existing systems.

And the paper consists of stuff like this:

This is not the stuff a 14 year old learns (unless your kid is some math genius like Terence Tao, at that point you would know it’s futile to waste money here). Even yours truly does not know it and hence is unable to explain it to you.

Finally let’s look at the third part. You’d expect some more advanced and juicy stuff.

Oh, so we are back to statistics marketed with buzzwords and captivating tasks. We also see a mention about absolute basic things like matrices and covariance, taught in class 12 and college courses which are not on AI or ML. Whitehatjr doesn’t fail to disappoint you more, isn’t it?

Before proceeding to the last part, I chanced upon a blog post of theirs. This absolutely shreds any credibility they may have in your mind, if you know stuff about programming.⁵ A prior knowledge about programming helps here.

Oh,

>programming language of HTML
>best use of PHP is interactive pages with WordPress and Drupal
>PHP is LITTLE difficult for “small” kids
>it is EASY to learn for more mature kids

So according to them Lua is the best introductory language, and Lua code is upon Roblox’s default (?) boilerplate (they didn’t even use the correct word and terminologies lmao).

Well, it turns out learning PHP and Lua was just scratch. Now the actual beast, Python, has entered into the game! Wow! Also, there is a very kid friendly reference, Python.org, quoted there!

>So the reason Java is popular is because of Minecraft.
>Minecraft has its own name among programming languages.
>Inb4 Java == Minecraft
>Minecraft as a learning tool for Java.
>Tfw you realise Minecraft is closed source.

Now, let’s see their privacy policy.⁶ I’ll just quote it here and add emphasis, since a screenshot would be too impractical.

We collect information that may be used to identify you or your Child (“Personal Information”) including, but not limited to, (i) name, e-mail ID, photograph, location and other contact information (ii) gender and other demographics (iii) birth date and year of the Child to validate their age.

We also collect certain information either when you provide it using the Platform or Services and/or automatically as you or the Child navigate through the Platform (which may include usage details, IP address, device ID and type, your browser type and language, the operating system used by the device, access times, and information collected through cookies, web beacons and other tracking technologies). You agree that we may use such information to do internal research on our Users’ demographics to better understand, protect and serve our Users.

So they collect all PII of the child, and track the child. But this is nothing, see the next part:

We collect information from your user ID associated with any social media account (such as your Facebook and Google account) that users use to sign into the Platform or connect with or use of our Services. When you sign in with your social media account information, or otherwise connect to your social media account with the Platform, you consent to our collection, storage, and use, in accordance with this Privacy Policy, of the information that you make available to us through the social media interface. This includes, without limitation, any information that you have made public through your social media account, information that the social media service shares with us or information that is disclosed during the sign-up and sign-in processes.

So any social media you link to them, they have the rights to store and mine every single shred of information on that profile which is public, plus the information you give them access to while signing in.

Basically, you are allowing them to collect every data available on your social media sites.

If any of the Users allows us to collect information from his or her device phonebook—and you or the Child’s are one of that User’s contacts—we may combine the information we collect from that User’s phonebook with other information we have collected about you. We may also obtain information from other sources and combine that with the information we collect through the Platform.

So they are correlating your profile and information with others, which includes using phonebook and mobile numbers.

So basically, you’re giving them a free pass to profile your children from their digital infancy. And they make it absolutely clear later:

You agree that we may use Personal Information about you to improve our marketing and promotional efforts, to analyse site usage, improve the Platform’s content and Service offerings, and customize the Platform’s content, layout, and Services. These uses improve the Platform and better tailor it to meet your needs, so as to provide you with an efficient, safe and customized experience while using the Platform.

So whitehatjr is basically

Bluffing around both at the homepage and at the curriculum.
Got technicalities about programming itself wrong. So much for teaching programming.
Meanwhile they capture every bit (pun intended) of information about you and your child to profile you and use it for more targetted advertisement and more tracking. Essentially monetising it while your child is profiled since day 1.
Your child gets nothing to learn and you lose money on sketchy claims.

Thanks for reading!

~ <Named link to my profile>

EDIT 1 (4/10/2020):

Here are some videos which will demonstrate the superior quality of education at whitehatjr!

https://youtu.be/qbtMCRRSsuc

https://youtu.be/E09n3BkrI_I

Both have been archived in case they get taken down.⁷ ⁸

What is the difference between cryptography and steganography?

Sun, 28 Jul 2019 00:00:00 +0000

Source: https://www.slideshare.net/kinleay/cryptography-its-history-application-and-beyond

Cryptography involves itself with encryption/decryption or hashing of the messages. It’s almost a mathematical field which has a profound practical impact on our lives. Generally, other guys must not be able to read your data, even if they get hold of it and know how it was encrypted.¹

Some of the most noticeable everyday life examples:

Most n00b example everyone comes across:
- Fb lbh svanyyl qrpelcgrq guvf! :-C
- If you didn’t know words are shifted by 13, this would be garbage for you.
To check if data is untampered as it was originally meant to be.²
It’s used to transmit data/messages in a secure and safe way so that any interceptor or evesdropper doesn’t get hold of what we are communicating or sending, i.e. secrecy of transmission of communication or data. One way to implement this is the RSA algorithm. But it’s not the only way and a myriad of algorithms, more or less powerful, exist.
- The lock you see on HTTPS websites is a direct consequence of this.³
As a related point to above, the infamous enigma machine.⁴
Storage and verification of passwords while logging in or otherwise.
Encryption of your stored data.⁵
- Having a lock/full disk encryption on your mobile. Your Android phone is decrypted on every reboot.⁶
Steganography (see the next section).

And much much much much more.

Steganography involves itself with hiding some file (image/executable/any file or data) in another file. Essentially you have data hidden in data, like, you hide a paper in a big folder. Not much mathematical theory (when compared to cryptography) is involved in this and is many times supplemented by cryptography.

It’s advantage over cryptography is that since data is hidden there’s a far less probability of suspicion than some exposed cryptic data in case of vanilla cryptographic data transfer. For example, let Germans use the enigma machine and suppose British got hold of it accidentally with a blank mind. Seeing the enigma message would immediately ring bells since the cryptic sequence seems too good to be random. Whereas in steganography that would be hidden behind another thing, like suppose a dank meme on Hitler and Churchill.

Some normal uses in a huge set of uses:

Very very very 5yo tier n00b rudimentary and a bad practical example is:
- NwnyynynfoofynyncNfwnxppbatengfnyncjyjxrwxfjxfykznxOmfwfaqhcibgrgurnafjrenxnyynfzfafxwnxuffygunajfzana
- Find a message in this! :)
Someone can hide an executable code in an image. Classic virus propagation strategy.⁷
You can hide your files behind another file.
Hide a message in an image so that it can be seen in a particular colour value only.⁸ Or in audio files.⁹ List is endless.
Printers printing barely visible data on every page about the machine and date time, so that the document can be traced back.¹⁰

And much much much more.

Thanks for reading!

What is the maximum amount of damage you can inflict on the universe by altering one word in any one of Newton's three laws of motion?

Wed, 13 Mar 2019 00:00:00 +0000

The holy second law is untouched till now (note: in the question thread), such is the power of the second law. It is in a way the basis of force as we perceive in daily life. Yeah, let’s play with the force itself.

Here’s the second law.

The rate of change of momentum of a body is directly proportional to the force applied, and this change in momentum takes place in the direction of the applied force.

So we write it in mathematical notation as $$ \vec{F} \propto \dot{\vec{p}} $$

I modify the law to be…

The rate of change of momentum of a body is inversely proportional to the force applied, and this change in momentum takes place in the direction of the applied force.

Oooh, so now the mathematical form would change to…

$$ \vec{F} \propto \dfrac{1}{\dot{\vec{p}}} $$

Oh, hey, since $\vec{p}=m\vec{v}$, as you slow down the force would increase.

That is, in familiar form…

$$ \vec{F} = \dfrac{1}{m\vec{a}} $$

I can’t fathom the craziness it would make… like, an ant commits a genocide?

To lessen the force, you would need to go more faster.

So when a car hits you, it needs to go faster to stop.

I must have made the grandfather of paradoxical physics proud.

On the flip side, we can travel faster than light. Yay!

(Pun totally not intended)

How can we improve Aadhaar's security?

Fri, 08 Mar 2019 00:00:00 +0000

Warning! Not your average bitching answer.

Well, let’s do a quick recap of what Aadhaar, an authentication system, does.

The end-user/application supplies some data to the system, like Aadhaar number, name, age, DOB, etc. which is to be authenticated.
The Aadhaar system compares this with its own record, and would like to verify with OTP and biometrics that the authentication request is indeed by the guy whose data is being processed.
If the comparison and verification is successful, the system would tell back that the information supplied is correct according to its record and hence, authenticated, and sometimes sends back the information in database.
The user/application sees this and does whatever it wants to do by getting the confirmation.

Isn’t this working sorta like…… password?

With the exception of sending back data, it is working exactly how a password works.

So… maybe we can get rid of the exception?!

Source: Introduction to Aadhaar, TRAI.¹

Aadhaar is primarily an authentication system. It is not concerned and doesn’t care two shits about what the end-user does with the information. A bank may use it for your account or government for DBT. All the system cares about is the integrity of information provided.

As far as I know, and I would be happy to be corrected, Aadhaar uses PKI+AES and sprinkle of other cryptographic functions to store the database as it is intact, with names and addresses available if requested by the system.

But Aadhaar is an authentication system. It should not be concerned about giving back any data. A yes/no reply by the system, as the same system does when verifying biometric², should ideally be the case.

Thus, we can make it to work and store the data just like password!

(If you don’t know how password works, my answer to In simple language, how do passwords work? How does an application reject the wrong password? would be a good introduction to it, along with terms like salting, hashing.)

Thus, Aadhaar data in database can be ideally treated as accounts, identified by the Aadhaar number or the virtual ID.

The details tied to the Aadhaar number can be salted and hashed, just like a password for, say, your Quora account.

Source: Pluke, CC0, via Wikimedia Commons.³

So when there’s an authentication request, the information supplied by the user would be salted and hashed, and then compared to the stored hashes! The verification (OTP, biometric stuff) can be done by the system as it did earlier. This improves the security, and it also has the potential to eliminate raw data transmission over the network entirely.

This way, integrity of data could be verified, and data leaks can be minimised because hashes are one-way cryptographic functions.⁴ Once you have a hash, you can’t have the thing which you hashed back from the hash, unless you brute-force (which would take trillions of years) or precomputed data in rainbow tables.⁵

The 2^n/2 bound⁶ for avoiding collision can easily be taken care of by, say, SHA512. The population of India (or the world) is unlikely to be anywhere near even 0.00000000000000000000000000000000000000000000000000000000000001% of 2²⁵⁶ .

There’s one thing to this, even the Government would be unable to access the raw data from UIDAI Aadhaar database when they would need to. But do they even need to? :)

Thanks for reading!

~ <Named Quora profile link signoff>

Conceptually, what is DDoS and darknet?

Mon, 25 Jun 2018 00:00:00 +0000

Essentially, without any pseudo-childish-hacking fuss, it simply goes like this:

DDoS attack is like a mob attack on a shop or a riot. When that happens, the shop is shut down and curfew maybe imposed on the area.
- DDoS is a coordinated attack on a web server, overflowing it with huge amounts of requests and traffic that the poor server’s resources are forced to become unavailable.

Darknet is just like an area of abandoned houses. You can ring their doorbells but you won’t get an answer back. You aren’t supposed to be there in the first place.
- A darknet is a portion of routed, allocated IP space not running any services. Traffic arriving to such IP dark space is undesired since it has no active hosts. ( Darknet - Wikipedia )

Dark web are websites which cannot be indexed by search engines and can only be accessed using special software. (Note that search engines can’t index your inbox, but you don’t need a special software to access your inbox. Your inbox is also referred as “deep web”.) Softwares and systems providing access to darknet cloak your identity by changing your names many times.
- Dark web’s overlay network route your connection through several proxies so that your identity is anonymous. These websites can’t be indexed by search engines and requires specially configured software to access them.

Don’t go by others on internet. This isn’t complicated, as you can see the similarity between points and sub points above.

One thing - Dark web isn’t dangerous in itself. Communicating and interacting with random strangers over the internet is.

Ignore online fanatic fantasies. And you’re good to go.

Is cryptography important? Why?

Mon, 16 Apr 2018 00:00:00 +0000

Let’s make it interesting.

Okay so for a minute think you’re an agent for intelligence agencies like IB/RAW. You have some top secret information about a new weapon system of another country which would wreck havoc in the world. You have to transfer the information obtained by espionage back to Delhi without getting caught, but the bummer is that you know someone named Eve is spying on you and would intercept any message you send.

How would you store and subsequently transfer the data?

This is where cryptography comes in.

When you apply the cryptographic algorithm (i.e use cryptography), your message changes, successfully hiding it for the time being. Hence the word crypto.

The message is said to be encrypted, which can be decrypted using algorithms, keys or passwords, depending upon the type of cryptographic method you use.

Now your espionage report doesn’t make any sense to Eve.

Your mission is successful. Congratulations!

Cryptography is important as it allows us to transfer data on an insecure, unencrypted, prone to eavesdropping environment. It’s like taking a bag of money in an area of criminals.

Cryptography is used in everyday life. It’s used in banking, CBSE board exams, confidential databases (like SSN, Aadhaar), sign-in on websites, and many more. It’s used even while you’re just browsing the internet, which is an extremely important application.

Cryptography is just lock and key.

In simple language, how do passwords work? How does an application reject the wrong password?

Sun, 24 Dec 2017 00:00:00 +0000

Almost on every reputed website password isn’t stored in plain-text. It is hashed ( Cryptographic hash function - Wikipedia) and salted. If you store passwords in plain-text then any intruder can just get hold of ’em.

A cryptographic hash function is, you can say, a mathematical algorithm (hence a function) to convert an arbitrary input (aka message) to a string (bit array, to be precise) of a fixed size, which is called a hash/digest. These are designed to be one-way functions, i.e., you can’t get the message from the hash. The only way is to brute-force (which could take millions of years for a strong password), or use rainbow tables (which contains precomputed data). Going deep into this subject is out of scope of this answer, as it requests explanation in simple terms.

Salt is a random string which is concatenated or added in the password for extra security, which is then hashed. In this way, the password is more secure as the hash of real password is different from the hash of salted password. For example,

Password = upvote_this_answer_NOW

Salt = shklf87et6ehbg

Salted password = upvote_this_answer_NOWshklf87et6ehbg

Salted password’s hash = e10be86c2fc46dcf669d49f5f29e1dd7b1bf4e135f07cb4541e106ee0a591db6d5823187b1e88154775f2a9c1e3926eb88ee68f1d9bbedd372324185118c4a10
Real password’s hash = fecf3e2c732cce39f056937cba78bbd4797b091865deb2eae88ef645cc167d353cf3d24163430268ba18c110e68c4b218eb369f341d82c334c673b464601443e

Clearly, the hashes¹ are different. (Future 2023 addendum: So the hacker doesn’t have to cringe at the shameless string, oh god I was stupid in 2017.)

Now, here’s what happens behind the scene when you enter a password:

You enter the password.
It is then salted.
The password is then hashed using the cryptographic hash functions in use.
The hash is compared to the stored hash. If it matches, the password is correct.

Contains excerpts from my answer to How does one create a strong password? Any tips?.

Thanks for reading!

Used SHA512. ↩︎

Has anyone solved the makkhichoose puzzle?

Tue, 05 Apr 2016 00:00:00 +0000

Well, they use that puzzle for hiring, so I won’t provide the answer here, or their purpose would be defeated.

But nevertheless, I will provide you a hint. Look at the JS file in POST data.

Confused? Can’t find? Here it is!


function sendData(in_data,dest_url) {
var req_send = $.ajax({
url: dest_url,
type: 'POST',
contentType: 'application/json',
data: in_data,
dataType: 'json'
});
return req_send;
}; //sendData
function munchClues(data) {
var makkhi_link= '<a href="MakkhiChoose" target="_blank" title="MakkhiChoose browser plug-in, open in new window">MakkhiChoose</a>';
var econ_link = '<a href="MakkhiChoose - Tricks and extensions to enhance your browsing experience - The Economic Times" target="_blank" title="Press Coverage in The Times of India">1.5 Lakh Indians</a>.';
var disp_arr=[ "Hey you! There's a puzzle in here. Click on the arrow for more clues.",
"This is a coding puzzle. You'll need to write some code.",
"It isn't tough. The clues are all here, in this page",
"But you'll have to look closely.",
"It might not even be in these sentences.",
"Look under the covers, as any good detective would",
"Once you get the secret phrase, type it in the box to the left",
"Who are we? We are the makers of "+makkhi_link,
"Dont have it? Install "+makkhi_link+" and you'll get one more BIG clue!",
"The best way to save while shopping online, according to more than "+econ_link,
"<b>You</b> can help us make it better, if you are good enough to crack this puzzle",
"OK, that's all the help you'll get. Good luck!"]
var disp_msg;
if (data['i']){
var next_val = parseInt(data['n']);
$('#riddle').attr('index',next_val-1);
$('#riddle').attr('next',next_val);
$('#riddle').attr('word',data['w']);
$('#riddle').html(disp_arr[(next_val-1)%12]);
if (next_val%5==0) {
$('#riddle').attr('message','Here is another hint for you: it involves some prime numbers. But not in a straightforward way.');
} else {
$('#riddle').removeAttr('message');
}
}
else {
$('#riddle').attr('index',0);
$('#riddle').attr('next',1);
$('#riddle').attr('word','right');
$('#riddle').attr('message','try numbers between 0 and 197');
disp_msg= "Hey you! There's a puzzle in here. Click on the arrow for more clues.";
$('#riddle').html(disp_msg);
}
}
function clueFail(data) {
disp_msg= "Whoops! Lots of puzzlers here. Can't reach the server, sorry. Try later";
$('#riddle').html(disp_msg);
}
function phraseFail(data) {
disp_msg= "Whoops! Lots of puzzlers here. Can't load the next clue, sorry. Try later";
typeAns(disp_msg);
}
function submitN() {
switchMCImage();
var i_val = $('#riddle').attr('next');
req_n = sendData(JSON.stringify({'i':i_val}),'/clue');
req_n.done(munchClues);
req_n.fail(clueFail);
}
function munchPhrase(data) {
if (data['i']){
typeAns(data['m']);
$('#riddle').remove();
$('#nBut').remove();
$('#askr').remove();
}
else {
var wrogn_kholi = Math.floor((Math.random()*16)+1);
if (wrogn_kholi<8) {
typeAns("Sorry, that isn't it.");
}
else {
typeAns(data['m']);
}
}
}//munchPhrase
function submitQ() {
if ($('#answr').hasClass('typing')) {
return true;
}
$('#answr').addClass('typing');
var sendQuest = true;
var q_val = $.trim($('textarea').val()).toLowerCase();
var answer_val;
if ((q_val == '') || (q_val=='type in the secret phrase...')){
answer_val = "That isn't it. Have you tried to solve the puzzle?";
sendQuest = false;
typeAns(answer_val);
}
else if ((q_val.match(/shit/gi)) || (q_val.match(/fuck/gi)) || (q_val.match(/dumb/gi)) || (q_val.match(/whore/gi))) {
answer_val = "Hey now! No reason to get snappy. Wash your mouth with soap water";
sendQuest = false;
typeAns(answer_val);
}
else if ((q_val.match(/cricket|baby|ipad|varun|windows|nokia|lumia/gi))) {
answer_val = "No, the clues are not in the images. This is a coding puzzle.";
sendQuest = false;
typeAns(answer_val);
}
else if ((q_val.match(/aaa/gi)) || (q_val.match(/jjj/gi)) || (q_val.match(/ooo/gi)) || (q_val.match(/abc/gi)) || (q_val.match(/sfg/gi)) || (q_val.match(/jkjk/gi)) || (q_val.match(/sdj/gi)) || (q_val.match(/sdg/gi)) || (q_val.match(/jhg/gi)) || (q_val.match(/asd/gi)) || (q_val.match(/\d/gi)) || (q_val.match(/puz/gi)) || (q_val.match(/rid/gi)) || (q_val.match(/que/gi)) || (q_val.match(/fuc/gi)) || (q_val.match(/shi/gi))) {
answer_val = "You are typing in random strings. That's a good strategy -- if you have a team of a hundred thousand monkeys";
sendQuest = false;
typeAns(answer_val);
}
else {

req_phrase = sendData(JSON.stringify({'q':q_val}),'/phrase');
req_phrase.done(munchPhrase);
req_phrase.fail(phraseFail);
}
} //submitQ
function typeAns(answer_val) {
$('#answr').empty();
var wordArray = answer_val.split(' '), i = 0;
INV = setInterval(function () {
if (i >= wordArray.length - 1) {
clearInterval(INV);
$('textarea').val('');
$('#answr').removeClass('typing');
switchMCImage();
}
$('#answr').append(wordArray[i] + ' ');
i++;
}, 200);
} //typeAns
function switchMCImage() {
var show_logo_int = Math.floor((Math.random()*6)+1);
$('#makkhiimg').attr('src','Makkhi/files/makkhi_alt_'+show_logo_int+'.png')
} //switchMCImage
function typeAnswer(answer_val) {
var wrdArray = answer_val.split(' '), i = 0;
return function(){
if (i >= wrdArray.length - 1) {
clearInterval(INV);
}
$el.append(wrdArray[i] + ' ');
} //closure
} //typeAnswer
var orig_img_src;
$(document).ready(function(){
orig_img_src = $('#rgimg').attr('src');
$('textarea').one('click',function(){$(this).html('');});
$('#qBut').click(submitQ);
$('#nBut').click(submitN);
$('textarea').keypress(function(e){
if(e.keyCode == 13 && !e.shiftKey) {
e.preventDefault();
if ($('#answr').hasClass('typing')) {
//do nothing
}
else {
submitQ();
}
}
});
});//documentready

Now I won’t say anything more. Rest is up to you.

If you are scratching your head for the other puzzle (which is fun & a LOT easier), then I will provide a solution for it here.

You need to put off the javascript timer of the website.

To do that, just enter this in the URL bar :

javascript:window.setTimeout = function(func, delay) {};window.setInterval = function(func, delay) {};document.getElementById("timer").innerHTML="200";

Now you have 200 seconds for that. And if you have difficulty finding the red box, then hold Ctrl+A and solve the puzzle.

Thanks for reading!

Bodha

Study resources for electronics and other subjects

Navigation

Introduction

Sources to avoid

Sources to consult

General

Mathematics

C Programming

Control Systems

Digital logic and VLSI

Digital System Design

Microprocessors and Microcontrollers

Advanced µc / µp, ARM7

VLSI Design

Embedded Systems and (RT)OS

VLSI Testing and Verification

Circuits

Network Theory

Analog Circuit Design

Signals and Systems

Continuous time

Discrete time / DSP

EM and Communication

Electromagnetic Theory

Analog and Digital Communication

Antenna and Propagation

Fibre Optic Communication

Wireless Communication

Networking and Protocols

Computer Networks

Internet of Things

AI

Artificial Intelligence

Machine Learning

Conclusion

Running keyutils tests

Kernel QEMU setup for development and debugging

Introduction

Cloning and saving the kernel

Setting up git

kgit_config

Setting up QEMU image

Configuring the kernel

kconfig

Building the kernel

kmake-all

Running the kernel in QEMU (you are probably here for this)

Explanation of the options we use

The command

Logging in

Terminating

kemulate

klogin

Editing fstab to mount /lib/modules inside the VM image

Decoding stacktrace

Getting maintainers

Migrated some content

About

Hi there!

What does “bodha” mean?

License

Sources

Credits

Search

Under Construction

High level introduction to KUnit

High level introduction to DRM subsystem

About DRM subsystem

DRM core basics - what and why

Need for tests

Why don't they just make CPUs bigger and add more transistors so we can have 10 GHz?

The curious mouse click

What is the difference between Hindi spelled हिन्दी and हिंदी?

How did people count before the invention of the number 0?

How is the site WhiteHat Jr. for teaching coding for children?

What is the difference between cryptography and steganography?

What is the maximum amount of damage you can inflict on the universe by altering one word in any one of Newton's three laws of motion?

How can we improve Aadhaar's security?

Conceptually, what is DDoS and darknet?