luckLab

Understanding Closures in JavaScript

luckLab — Tue, 01 Jul 2025 00:00:00 GMT

Closures are a fundamental concept in JavaScript that allow functions to access variables from their outer scope. Here's an example:

function outerFunction(outerVariable) {
  return function innerFunction(innerVariable) {
    console.log(`Outer Variable: ${outerVariable}`)
    console.log(`Inner Variable: ${innerVariable}`)
  }
}

const newFunction = outerFunction('outside')
newFunction('inside')

Closures are particularly useful for creating private variables and functions. For example:

function Counter() {
  let count = 0
  return {
    increment: () => count++,
    getCount: () => count,
  }
}

const counter = Counter()
counter.increment()
console.log(counter.getCount()) // 1

Closures are a powerful tool in JavaScript, enabling encapsulation and modularity.

TypeScript Generics Explained

luckLab — Wed, 02 Jul 2025 00:00:00 GMT

Generics in TypeScript allow you to create reusable and type-safe components. Here's a simple example:

function identity<T>(arg: T): T {
  return arg
}

console.log(identity<string>('Hello'))
console.log(identity<number>(42))

Generics can also be used with classes and interfaces:

class Box<T> {
  private content: T

  constructor(content: T) {
    this.content = content
  }

  getContent(): T {
    return this.content
  }
}

const stringBox = new Box<string>('TypeScript')
console.log(stringBox.getContent())

Generics are a powerful feature that can make your TypeScript code more flexible and maintainable.

Python Decorators Demystified

luckLab — Thu, 03 Jul 2025 00:00:00 GMT

Decorators in Python are a powerful way to modify the behavior of functions or methods. Here's a simple example:

def decorator_function(original_function):
    def wrapper_function(*args, **kwargs):
        print(f"Wrapper executed before {original_function.__name__}")
        return original_function(*args, **kwargs)
    return wrapper_function

@decorator_function
def say_hello():
    print("Hello!")

say_hello()

Decorators can also be used with arguments:

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Hi!")

greet()

Decorators are widely used in Python for logging, access control, and more.

python -c "@decorator_function\ndef say_hello():\n    print(\"Hello!\")\nsay_hello()"

Concurrency in Go

luckLab — Fri, 04 Jul 2025 00:00:00 GMT

Go is known for its excellent support for concurrency. The primary tools for concurrency in Go are goroutines and channels. Here's an example:

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

Channels are used to communicate between goroutines:

package main

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // send sum to channel
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // receive from channel

    fmt.Println(x, y, x+y)
}

Go's concurrency model is simple yet powerful, making it a great choice for concurrent programming.

go run concurrency_example.go

Mastering Async/Await in JavaScript

luckLab — Sat, 05 Jul 2025 00:00:00 GMT

Async/await simplifies working with asynchronous code in JavaScript. Here's an example:

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data')
    const data = await response.json()
    console.log(data)
  } catch (error) {
    console.error('Error fetching data:', error)
  }
}

fetchData()

Async/await is built on top of Promises and makes the code more readable and maintainable.

node -e "(async () => { const response = await fetch('https://api.example.com/data'); console.log(await response.json()); })()"

TypeScript Utility Types

luckLab — Sun, 06 Jul 2025 00:00:00 GMT

TypeScript provides several utility types to make your code more concise and type-safe. For example:

interface User {
  id: number
  name: string
  email: string
}

// Partial makes all properties optional
const updateUser: Partial<User> = { name: 'New Name' }

// Readonly makes all properties read-only
const readonlyUser: Readonly<User> = { id: 1, name: 'John', email: 'john@example.com' }

// Pick selects specific properties
const userName: Pick<User, 'name'> = { name: 'John' }

// Omit removes specific properties
const userWithoutEmail: Omit<User, 'email'> = { id: 1, name: 'John' }

Utility types are a great way to work with complex types in TypeScript.

echo "Using Partial, Readonly, Pick, and Omit in TypeScript"

Python's List Comprehensions

luckLab — Mon, 07 Jul 2025 00:00:00 GMT

List comprehensions provide a concise way to create lists in Python. Here's an example:

# Create a list of squares
squares = [x**2 for x in range(10)]
print(squares)

# Filter even numbers
evens = [x for x in range(10) if x % 2 == 0]
print(evens)

# Nested comprehensions
matrix = [[i * j for j in range(5)] for i in range(5)]
print(matrix)

List comprehensions are a powerful feature for creating and transforming lists in Python.

python -c "print([x**2 for x in range(10)])"

Error Handling in Go

luckLab — Tue, 08 Jul 2025 00:00:00 GMT

Go uses a simple and explicit approach to error handling. Here's an example:

package main

import (
    "errors"
    "fmt"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

Error handling in Go is straightforward and encourages developers to handle errors explicitly.

go run error_handling.go

JavaScript's Event Loop Explained

luckLab — Wed, 09 Jul 2025 00:00:00 GMT

The event loop is a critical part of JavaScript's runtime, enabling asynchronous programming. Here's a simple example:

console.log('Start')

setTimeout(() => {
  console.log('Timeout')
}, 0)

console.log('End')

Output:

Start
End
Timeout

The event loop ensures that the call stack is empty before executing tasks from the callback queue. This mechanism allows JavaScript to handle asynchronous operations efficiently.

node -e "console.log('Start'); setTimeout(() => { console.log('Timeout'); }, 0); console.log('End');"

Advanced TypeScript: Conditional Types

luckLab — Thu, 10 Jul 2025 00:00:00 GMT

echo "Exploring advanced TypeScript features like conditional types"

3 Test

#test

Conditional types in TypeScript allow you to create types based on conditions. Here's an example:

type IsString<T> = T extends string ? true : false

const test1: IsString<string> = true // Valid
const test2: IsString<number> = false // Valid

Conditional types are particularly useful for creating flexible and reusable type definitions.

Python's Generators and Yield

luckLab — Fri, 11 Jul 2025 00:00:00 GMT

Generators in Python are a way to create iterators using the yield keyword. Here's an example:

def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

for number in count_up_to(5):
    print(number)

Generators are memory-efficient and allow you to work with large datasets without loading them entirely into memory.

python -c "def count_up_to(n):\n    count = 1\n    while count <= n:\n        yield count\n        count += 1\nfor number in count_up_to(5):\n    print(number)"

Go's Interfaces and Polymorphism

luckLab — Sat, 12 Jul 2025 00:00:00 GMT

Interfaces in Go provide a way to achieve polymorphism. Here's an example:

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func printArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

func main() {
    c := Circle{Radius: 5}
    r := Rectangle{Width: 4, Height: 6}

    printArea(c)
    printArea(r)
}

Interfaces in Go are a powerful way to write flexible and reusable code.

go run interfaces_example.go

JavaScript's Prototypal Inheritance

luckLab — Sun, 13 Jul 2025 00:00:00 GMT

Prototypal inheritance is a feature in JavaScript that allows objects to inherit properties and methods from other objects. Here's an example:

const parent = {
  greet() {
    console.log('Hello from parent!')
  },
}

const child = Object.create(parent)
child.greet() // Hello from parent!

Prototypal inheritance is a flexible way to share behavior between objects without using classes.

node -e "const parent = { greet() { console.log('Hello from parent!'); } }; const child = Object.create(parent); child.greet();"

TypeScript's keyof and Mapped Types

luckLab — Mon, 14 Jul 2025 00:00:00 GMT

The keyof operator and mapped types in TypeScript allow for advanced type manipulation. Here's an example:

interface User {
  id: number
  name: string
  email: string
}

type UserKeys = keyof User // 'id' | 'name' | 'email'

type ReadonlyUser = {
  [K in keyof User]: Readonly<User[K]>
}

const user: ReadonlyUser = {
  id: 1,
  name: 'John',
  email: 'john@example.com',
}

// user.id = 2; // Error: Cannot assign to 'id' because it is a read-only property.

These features make TypeScript a powerful tool for creating robust and type-safe applications.

echo "Using keyof and mapped types in TypeScript"

Python's Context Managers and the with Statement

luckLab — Tue, 15 Jul 2025 00:00:00 GMT

Context managers in Python are used to manage resources efficiently. Here's an example:

with open('example.txt', 'w') as file:
    file.write('Hello, world!')

You can also create custom context managers using classes or the contextlib module:

from contextlib import contextmanager

@contextmanager
def custom_context():
    print('Entering context')
    yield
    print('Exiting context')

with custom_context():
    print('Inside context')

Context managers ensure that resources are properly cleaned up, making your code more reliable and maintainable.

python -c "with open('example.txt', 'w') as file: file.write('Hello, world!')"

Showing Off Blog Features

luckLab — Sun, 20 Jul 2025 00:00:00 GMT

Since the post does not have a description in the frontmatter, the first paragraph is used.

Theming

Use your favorite editor theme for your blog!

Theming for the website comes from builtin Shiki themes found in Expressive Code. You can view them here. A website can have one or more themes, defined in src/site.config.ts. There are three theming modes to choose from:

single: Choose a single theme for the website. Simple.
light-dark-auto: Choose two themes for the website to use for light and dark mode. The header will include a button for toggling between light/dark/auto. For example, you could choose github-dark and github-light with a default of "auto" and the user's experience will match their operating system theme straight away.
select: Choose two or more themes for the website and include a button in the header to change between any of these themes. You could include as many Shiki themes from Expressive Code as you like. Allow users to find their favorite theme!

When the user changes the theme, their preference is stored in localStorage to persist across page navigation.

Code Blocks

Let's look at some code block styles:

def hello_world():
    print("Hello, world!")

hello_world()

def hello_world():
    print("Hello, world!")

hello_world()

python hello.py

Also some inline code: 1 + 2 = 3. Or maybe even (= (+ 1 2) 3).

See the Expressive Code Docs for more information on available features like wrapping text, line highlighting, diffs, etc.

Basic Markdown Elements

List item 1
List item 2

Bold text

Italic text

~~Strikethrough text~~

Link

In life, as in art, some endings are bittersweet. Especially when it comes to love. Sometimes fate throws two lovers together only to rip them apart. Sometimes the hero finally makes the right choice but the timing is all wrong. And, as they say, timing is everything.

- Gossip Girl

Name	Age	City
Alice	30	New York
Bob	25	Los Angeles
Charlie	35	Chicago

Images

Images can include a title string after the URL to render as a <figure> with a <figcaption>.

![Pixel art of a tree](PixelatedGreenTreeSide.png 'Pixel art renders poorly without proper CSS')

I've also added a special tag for pixel art that adds the correct CSS to render properly. Just add #pixelated to the very end of the alt string.

![Pixel art of a tree #pixelated](PixelatedGreenTreeSide.png 'But adding #pixelated to the end of the alt string fixes this')

Admonitions

:::note
testing123
:::

:::note testing123 :::

:::tip testing123 :::

:::important testing123 :::

:::caution testing123 :::

:::warning testing123 :::

Character Chats

:::duck
**Did you know?** You can easily create custom character chats for your blog with MultiTerm!
:::

:::duck Did you know? You can easily create custom character chats for your blog with MultiTerm! :::

Adding Your Own

To add your own character, first add an image file to the top-level /public directory in your cloned MultiTerm repo. Astro cannot automatically optimize image assets from markdown plugins, so make sure to compress the image to a web-friendly size (<100kb).

I recommend Google's free Squoosh web app for creating super small webp files. The characters here have been resized to 300 pixels wide and exported to webp with 75% quality using Squoosh.

After you've added your image, update the characters option in site.config.ts with your newly added image file and restart the development server.

Character Conversations

When there are multiple character chats in a row, the order of the chat image and chat bubble reverses to give the chat more of a back-and-forth appearance.

:::owl
This is a cool feature!
:::

:::unicorn
I agree!
:::

:::owl This is a cool feature! :::

:::unicorn I agree! :::

You can specify the alignment (left or right) to override the default left, right, left, ... ordering.

:::unicorn{align="right"}
Over here, to the right!
:::

:::unicorn{align="right"} Over here, to the right! :::

GitHub Cards

GitHub overview cards heavily inspired by Astro Cactus.

::github{repo="stelcodes/multiterm-astro"}

::github{repo="stelcodes/multiterm-astro"}

::github{user="withastro"}

::github{user="withastro"}

Emoji :star_struck:

Emojis can be added in markdown by including a literal emoji character or a GitHub shortcode. You can browse an unofficial database here.

Good morning! :sleeping: :coffee: :pancakes:

Good morning! :sleeping: :coffee: :pancakes:

All emojis (both literal and shortcoded) are made more accessible by wrapping them in a span tag like this:
<span role="img" aria-label="coffee">☕️</span>
At the time of writing, emoji v16 is not supported yet. These emojis can be included literally but they do not have shortcodes and will not be wrapped.

LaTeX/KaTeX Math Support

You can also display inline math via remark-math and rehype-katex.

Make those equations pretty! $ \frac{a}{b} \cdot b = a $

Make those equations pretty! $ \frac{a}{b} \cdot b = a $

Check out the KaTeX docs to learn about the syntax.

$$
a + ar + ar^2 + ar^3 + \dots + ar^{n-1} = \displaystyle\sum_{k=0}^{n - 1}ar^k = a \bigg(\dfrac{1 - r^n}{1 -r}\bigg)
$$

$$ a + ar + ar^2 + ar^3 + \dots + ar^{n-1} = \displaystyle\sum_{k=0}^{n - 1}ar^k = a \bigg(\dfrac{1 - r^n}{1 -r}\bigg) $$

HTML Elements

<button>A Button</button>

Fieldset with Inputs

<fieldset> <input type="text" placeholder="Type something"><br> <input type="number" placeholder="Insert number"><br> <input type="text" value="Input value"><br> <select> <option value="1">Option 1</option> <option value="2">Option 2</option> <option value="3">Option 3</option> </select><br> <textarea placeholder="Insert a comment..."></textarea><br> <label><input type="checkbox"> I understand<br></label> <button type="submi">Submit</button> </fieldset>

Form with Labels

<form> <label> <input type="radio" name="fruit" value="apple"> Apple </label><br>

<label> <input type="radio" name="fruit" value="banana"> Banana </label><br>

<label> <input type="radio" name="fruit" value="orange"> Orange </label><br>

<label> <input type="radio" name="fruit" value="grape"> Grape </label><br>

<label> <input type="checkbox" name="terms" value="agree"> I agree to the terms and conditions </label><br>

bochs调试

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

b 0x1500 //走到1500内存处停下来 s 1 //单步执行 n //单步执行 show int //开始中断跟踪 sba 17362299 //执行了多少调指令后停下来 print-stack //打印栈

00017362300:

sba 17362299

bochs:24 r eax: 0x00000020 32 ecx: 0xc0002027 -1073733593 edx: 0x00000000 0 ebx: 0xc0003ff4 -1073725452

esp: 0xc009efb0 -1073090640 ebp: 0xc009eff8 -1073090568

esi: 0x00072000 466944 edi: 0xc0004000 -1073725440 eip: 0xc00018f3 eflags 0x00000092: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf AF pf cf

eax: 0xc0002275 -1073733003 ecx: 0xc0002027 -1073733593 edx: 0x00000000 0 ebx: 0xc0003ff4 -1073725452

esp: 0xc009efe0 -1073090592 ebp: 0xc009eff8 -1073090568

esi: 0x00072000 466944 edi: 0xc0004000 -1073725440 eip: 0xc00018fa eflags 0x00000092: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf AF pf cf

----------退回中断前------------

| STACK 0xc009efe4 [0xc0001533] | STACK 0xc009efe8 [0x00000008] | STACK 0xc009efec [0x00000286]

eax: 0xc0002275 -1073733003 ecx: 0xc0002027 -1073733593 edx: 0x00000000 0 ebx: 0xc0003ff4 -1073725452 esp: 0xc009efe4 -1073090588 ebp: 0xc009eff8 -1073090568 esi: 0x00072000 466944 edi: 0xc0004000 -1073725440 eip: 0xc00018fd eflags 0x00000086: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af PF cf

es:0x0010, dh=0x00cf9300, dl=0x0000ffff, valid=1 Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed cs:0x0008, dh=0x00cf9900, dl=0x0000ffff, valid=1 Code segment, base=0x00000000, limit=0xffffffff, Execute-Only, Non-Conforming, Accessed, 32-bit ss:0x0010, dh=0x00cf9300, dl=0x0000ffff, valid=7 Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed ds:0x0010, dh=0x00cf9300, dl=0x0000ffff, valid=1 Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed fs:0x0000, dh=0x00001000, dl=0x00000000, valid=0 gs:0x0018, dh=0xc0c0930b, dl=0x80000007, valid=1 Data segment, base=0xc00b8000, limit=0x00007fff, Read/Write, Accessed ldtr:0x0000, dh=0x00008200, dl=0x0000ffff, valid=1 tr:0x0000, dh=0x00008b00, dl=0x0000ffff, valid=1 gdtr:base=0xc0000903, limit=0x1f idtr:base=0x00004320, limit=0x107

eax: 0xc0002275 -1073733003 ecx: 0xc0002027 -1073733593 edx: 0x00000000 0 ebx: 0xc0003ff4 -1073725452 esp: 0xc009eff0 -1073090576 ebp: 0xc009eff8 -1073090568 esi: 0x00072000 466944 edi: 0xc0004000 -1073725440 eip: 0xc0001533 eflags 0x00000286: id vip vif ac vm rf nt IOPL=0 of df IF tf SF zf af PF cf

段描述符

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

段描述符

段基址: 32位宽在16-31(16) 32-29(8) 56-63(8位)

段界限：即能寻址的最大范围(20位)(单位量)(字节/4kb)

g: 0 1字节 1 4k (2的20次方=1m) (1m*4k=4g)

s: 0 系统段(不是硬件需要的都不是系统段) 1 数据段

type: 4位 x r c a x(执行) r(读) c(一致性) a(是否访问过) a是cpu设置的(设置为0由cpu改)

dpl: 描述符权限级 2位越小权限越大

p：段是否存在在内存中是1 不在是0 如果是0,cup会抛异常

avl: 可用位

l: 1 64位代码段 32是0

D/B: d=0 16位 1 32位

G: 指定段界限的单位大小

gdt 段描述符表用于存储段描述符(数组)(通过下标查找各个gd)

gdtR 即存放gdt的寄存器,存放gdt的首地址

gdtr寄存器是全局描述符的指针 48位 32位gdt起始地址 16位gdt界限只能使用lgdt指令操作

选择子

选择子是16位数, 存放在段寄存器里(cs,ds,ss) 实模式时是段基址地址,保护模式时是选择子保护模式段基址地址已经存在段描述符里了,所以选择子里存放的是指向gdt里的某个段描述符的索引

ti: 0 gdt(全局描述符) 1 ldt(局部描述符) rpl: 请求特权级 2位

段描述符缓冲寄存器

目的：段描述符在内存中,频繁访问速度较慢,所以引入段描述符缓冲寄存器

进程

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

进程

进程 = 资源 + 线程
一个线程是一个执行流进程会创建单独的页表

PCB 程序控制块(Process Control Block)

记录进程状态,PID,优先级等

输入系统

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

键盘操作，当按键按下后,键盘内8048芯片通过ps/2协议发送按键码给主板上的8042芯片,8042负责触发中断,让cpu读取数据

页表机制

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

分页机制

页表是凌驾于分段机制之上的,也凌驾于保护模式的段描述符之上的

逻辑地址线性地址和物理地址

逻辑地址 ds里存放选择子,通过选择子找到段描述符，段描述符映射到段基地址 :偏移量 => 线性地址。

线性地址关闭分页 ==> 物理地址开启分页 -> 查页目录和页表 ->找到物理地址

        ┌───────────────────────┐
        │ 逻辑地址 (Logical)     │
        │ 例如: DS:0x1234        │
        └───────────┬───────────┘
                    │
                    ▼
        ┌───────────────────────┐
        │ 段描述符 (Segmentation) │
        │ GDT/LDT 提供 Base+Limit│
        └───────────┬───────────┘
                    │
                    ▼
        ┌───────────────────────┐
        │ 线性地址 (Linear)      │
        │ Base + Offset          │
        │ 例如: 0x00401234       │
        └───────────┬───────────┘
                    │
            [分页开关 CR0.PG=1?]
                    │
    ┌───────────────┴─────────────────┐
    │                                 │
    ▼                                 ▼

┌─────────────────────┐ ┌──────────────────────┐ │ 分页机制关闭 │ │ 分页机制开启 │ │ Linear = Physical │ │ 查页目录 + 页表 │ └───────────┬─────────┘ └───────────┬──────────┘ │ │ ▼ ▼ ┌──────────────────┐ ┌───────────────────┐ │ 物理地址 (Physical) │ │ 物理地址 (Physical) │ │ 直接访问 RAM 芯片 │ │ 页表映射后的地址 │ └──────────────────┘ └───────────────────┘

开启分页后的逻辑 => 线性地址到物理地址

线性地址32位分为三段 31-22 页目录索引 Page Directory(页目录) 用于查到目录项(pde) 21-12 页表索引从pde里通过Page Table(pt)找到页表项(pte) 11-0 页内偏移对应物理页的偏移量

举个例子: 0x12345678 12 3 45 678

12 = 18 => 0001 0010 3 = 0011 pd(10bit)= 0001 0010 00 = 0100 1000 = 0x48 pt(10bit)= 11 0100 0101 = 0x345 偏移 = 0x678

查页目录->通过0x48找到页表的物理地址
查页表 -> 通过0x345找到页框基地址
找到具体地址 -> 页框基地址+0x678 等到物理地址

物理页帧和页项

都是4k为单位,如果4g内存会划分 1m个页表项,每个页表项4字节,需要4m来存储

一级页表

段部件输出线性地址线性地址的高20位是索引(1m) 低12位(4k)为偏移量查页表 -> 获取到页表项里的物理地址基地址物理地址基地址+12位偏移量 -> 找到具体的物理地址

pte 页表项

pte 4b => 32位高20位表示物理页框号低12位用于权限等元数据物理页框号*4k + 偏移量就能找到具体的物理内存

一级页表如果要表示4g的空间,一个pte 能表示 4k的空间，则需要 4g/4k * 4 的内存来存储 4g/4k = 1m

二级页表

一个页表项范围是4k,页尺寸不变都是4k,则一个页能有4k/4=1024个页表项所以 4k * 1024 = 4m 代表一个页表能映射4m 4g/4m = 1024个页表,则二级页表需要有1024个页目录项 1024个页目录项*4 = 4k,则正好又等于一个物理页的大小

二级页表页目录项

tss任务状态段

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

tss (Task State Segment) 任务状态段

tss用于记录任务切换时状态的快照,tss描述符存储在gdt中,
当前任务的tss存储在tr寄存器中

tss描述符格式(tss描述符并不是tss)

tss描述符可以获取到tss的基地址和界限
配合tss选择子才能找到真正的tss

s=0 代表系统段
type-b位=1 代表任务繁忙 0 代表空闲由cpu操作,也防止被重入

elf可执行文件

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

elf 是目标文件格式就是可执行文件

格式是 elf头, 段头和节头,实际程序代码

elf 文件头

typedef struct
{
  /**
   * [0x7f,'E','L','F' 前4位是魔术,固定 
   * index:4 elf文件类型  5 编码格式大小端 6版本信息 7-15保留位
   * ]
  */
  unsigned char e_ident[EI_NIDENT];     /* Magic number and other info */
  Elf32_Half    e_type;                 /* Object file type 目标文件类型 2字节  */
  Elf32_Half    e_machine;              /* Architecture 指定在哪个平台运行 */
  Elf32_Word    e_version;              /* Object file version 版本信息*/
  Elf32_Addr    e_entry;                /* Entry point virtual address 运行程序的虚拟地址 */
  Elf32_Off     e_phoff;                /* Program header table file offset 用于指明程序头表*/
  Elf32_Off     e_shoff;                /* Section header table file offset 用于指明节头表 */
  Elf32_Word    e_flags;                /* Processor-specific flags 指明和处理器相关表示 */
  Elf32_Half    e_ehsize;               /* ELF header size in bytes 指明elf header的字节大小 */
  Elf32_Half    e_phentsize;            /* Program header table entry size 指明程序头表各个entry的字节大小 */
  Elf32_Half    e_phnum;                /* Program header table entry count 指明程序头表长度 */
  Elf32_Half    e_shentsize;            /* Section header table entry size 指明节头各entry的字节大小*/
  Elf32_Half    e_shnum;                /* Section header table entry count 节头长度 */
  Elf32_Half    e_shstrndx;             /* Section header string table index 用来指明string name table在节头表中的索引index */
} Elf32_Ehdr;

elf 程序头结构体

typedef struct
{
  Elf32_Word    p_type;                 /* Segment type 段类型4字节*/
  Elf32_Off     p_offset;               /* Segment file offset 用于指明本段在文件内的起始偏移字节*/
  Elf32_Addr    p_vaddr;                /* Segment virtual address 用于指明本段在内存中的起始虚拟地址 */
  Elf32_Addr    p_paddr;                /* Segment physical address */
  Elf32_Word    p_filesz;               /* Segment size in file 本段在文件中的大小*/
  Elf32_Word    p_memsz;                /* Segment size in memory 本段在内存中的大小 */
  Elf32_Word    p_flags;                /* Segment flags 指明与本段相关的标志*/
  Elf32_Word    p_align;                /* Segment alignment 指明本段在文件和内存中的对齐方式 */
} Elf32_Phdr;

elf文件示例

00000000: 7F 45 4C 46 (魔术elf) 01(32位) 01(小端) 01(当前版本) 00 00 00 00 00 00 00 00 00  .ELF............
00000010: 02 00(小端) 03 00(EM386 80386平台) 01 00 00 00(版本) 00 15 00 C0(程序的虚拟入口地址) 34 00 00 00(程序头表偏移量)  ............4...
00000020: 4C 21 00 00(节头表偏移位置)00 00 00 00(e_flag) 34 00(e_ehsize程序头位置) 20 00(段的结构体的大小) 06 00(程序头中段的个数) 28 00(节头表各个节的大小)  L!......4. ...(.
00000030: 08 00(8个节) 07 00(节头索引为7) (程序头表开始位置)01 00 00 00(可加载程序段) 00 00 00 00(本段在文件中的偏移量 0) 00 10 00 C0(本段加载到内存后的起始虚拟地址)  ................
00000040: 00 00 00 C0(0x0000c0) F4 00 00 00(0xf4本段在文件中的字节大小) F4 00 00 00(0xf400在内存中的大小) 04 00 00 00  ................
00000050: 00 10 00 00(1段) 01 00 00 00 00 05 00 00 00 15 00 C0  ................
00000060: 00 15 00 C0 18 00 00 00 18 00 00 00 05 00 00 00  ................
00000070: 00 10 00 00 01(2段) 00 00 00 00 10 00 00 00 20 00 C0  ............. ..
00000080: 00 20 00 C0 4C 00 00 00 4C 00 00 00 04 00 00 00  . ..L...L.......
00000090: 00 10 00 00 01 00(3段) 00 00 F4 1F 00 00 F4 3F 00 C0  .............?..
000000a0: F4 3F 00 C0 0C 00 00 00 0C 00 00 00 06 00 00 00  .?..............
000000b0: 00 10 00 00 51 E5 74(4段) 64 00 00 00 00 00 00 00 00  ....Q.td........
000000c0: 00 00 00 00 00 00 00 00 00 00 00 00 06 00 00 00  ................
000000d0: 10 00 00 00 52 E5 74(5段) 64 F4 1F 00 00 F4 3F 00 C0  ....R.td.....?..
000000e0: F4 3F 00 C0 0C 00 00 00 0C 00 00 00 04 00 00 00  .?..............
000000f0: 01 00 00 00 00 00 00 00(6段) 00 00 00 00 00 00 00 00  ................
00000100: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
00000110: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
00000120: 00 00 00 00 00 00 00 00 00 00 00 00              ............

操作系统中断

luckLab — Thu, 01 Jan 2026 00:00:00 GMT

中断按照事件来源分类:

外部中断: 
   可屏蔽中断:
   不可屏蔽中断:
内部中断:
   软中断:
   异常:

外部中断:

外部中断的中断源是某个硬件,所以外部中断又称硬件中断。
比如网卡收到网络数据包,会通知cpu,cpu得到通知以后将数据拷贝到内核缓冲区。

外部中断如果cpu像单片机一样都提供gpio接口,那无穷无尽的外设肯定会不够用, 所以cpu提供统一的接口作为中断信号的公共线路

cpu提供了两条信号线。INTR(InteRrupt)和NMI(Non Maskable Interrupt) 即可屏蔽和不可屏蔽中断(2)

内部中断

软中断：即软件中断 int3

中断描述符表 idt interrupt descriptor table

用于保护模式存储中断的,存中断描述符和任务门描述符和陷阱门描述符

其实是存的一段代码的起始地址,所以又叫门

门顾名思义就是通往某个地方的大门，这里是一段程序

中断门

包含中断处理程序所在的段的段选择子和段内偏移量才能得到一段程序

linux就是使用的中断门实现的系统调用, int 0x80
中断门的 type=1110

中断描述符表寄存器 idtr interrupt descriptor table register

用于找到中断描述符表,6字节 48位,使用lidt 48位内存地址数据来加载idt

0-15 存储idt的大小-1,最大2^16=64kb
16-47 中断描述符表的地址

中断发生,处理器收到 中断向量号,根据中断向量号 -> 中断描述符表(对应中断描述符)
中断描述符中(代码段选择子,段内偏移量)处理器加载选择子到cs,偏移量到eip,把当前的cs:eip保存到中断处理程序的栈中
还需要保存标志寄存器eflags,牵扯到特权级变化还要压入ss和esp

拿到中断描述符后,那cpl和选择子对应的目标代码段的dpl(在段描述符里)对比,cpl>dpl 表示向高特权级转移,所以处理器需要先
保存旧的ss和esp记作ss_old和esp_old,然后再tss里找到dpl级别的栈,加载到ss和esp

BeanDefinition 讲解

luckLab — Fri, 02 Jan 2026 00:00:00 GMT

BeanDefinition 讲解

Spring 源码中一个非常重要的概念：BeanDefinition

流程

BeanDefinitionReader 读取BeanDefinition,放入BeanFactory，
BeanFactory通过getBean来生成实例

spring boot 注册流程

首先在项目启动后，
在refreshContext(刷新上下文)=>invokeBeanFactoryPostProcessor(工厂后置处理器)
=>invokeBeanDefinitionRegistryPostProcessors =>ConfigurationClassPostProcessor=>

Spring Security 过滤器链解析

luckLab — Fri, 02 Jan 2026 00:00:00 GMT

Spring Security 过滤器链解析

Spring Security 的所有逻辑都是基于过滤器链的，这里简单介绍一下 Spring Security 的过滤器链。

1. ApplicationFilterChain

ApplicationFilterChain 实现了 FilterChain，由 Tomcat 构建此过滤器链。
由 ApplicationFilterFactory.createFilterChain(request, wrapper, servlet); 创建。
过滤器列表示例：[... DelegatingFilterProxy]。

2. DelegatingFilterProxy

DelegatingFilterProxy 是一个过滤器，间接注册在 ApplicationFilterChain 中。
它是 WebMvcSecurityConfiguration.CompositeFilterChainProxy 的装饰器。

3. CompositeFilterChainProxy

CompositeFilterChainProxy 是 Security 真实的过滤器链。
它是一个过滤器链代理，里面有 List<Filter> doFilterDelegate 作为核心属性。

4. doFilterDelegate 过滤器链

doFilterDelegate 会构建一个 VirtualFilterChain 过滤器链，其中包含 [HandlerMappingIntrospector.createCacheFilter, FilterChainProxy]。

5. FilterChainProxy

FilterChainProxy 是 Spring Security 提供的过滤器链代理。
其中包含 List<SecurityFilterChain> filterChains，管理不同请求的不同过滤器链。
通过url路径匹配具体的 SecurityFilterChain。

6. SecurityFilterChain

其实现类 DefaultSecurityFilterChain，是具体的过滤器链对象。
其中包含构建 FilterChain 的过滤器和匹配规则。
主要属性：
- RequestMatcher requestMatcher
- List<Filter> filters
FilterChainProxy 通过 requestMatcher 匹配 filters。

7. VirtualFilterChain

VirtualFilterChain 是 FilterChainProxy 的一个内部类。
它是 FilterChain 的具体实现。
在第 2 步获取到过滤器后，会构建 VirtualFilterChain，这个链是真正的 Spring Security 过滤器链。

具体参考官网的这个图片：

SAML 单点登录

luckLab — Fri, 02 Jan 2026 00:00:00 GMT

SAML 单点登录（SSO）指南

1. 什么是 SAML？

SAML（Security Assertion Markup Language）是一种基于 XML 的开放标准，用于在身份提供者（IdP）和服务提供者（SP）之间交换身份认证和授权数据。

2. SAML 单点登录（SSO）流程

SAML SSO 允许用户使用单个身份在多个应用程序之间进行无缝登录。典型流程如下：

名称	描述
sp	服务提供者
idp	身份提供者

用户访问 SP（服务提供者）
- 例如，用户访问 http://loclhost:8080/user。
SP 重定向到 IdP（身份提供者）
- SP 生成 SAML 认证请求，并将用户重定向到 IdP（如 Okta、Keycloak、ADFS）。
用户在 IdP 认证
- 用户输入凭据（用户名/密码、多因素认证等）。
- 认证成功后，IdP 生成 SAML 响应。
IdP 返回 SAML 响应
- IdP 通过浏览器 POST SAML 断言（Assertion）到 SP 预定义的 ACS（Assertion Consumer Service）URL。
SP 解析 SAML 断言并创建会话
- SP 验证 SAML 断言的签名和有效性。
- 解析用户信息，创建应用会话，并完成登录。
用户成功访问受保护资源
- 认证成功后，用户可以访问 SP 的受保护页面。

3. Spring Security SAML2 配置

实现sp过程,使用okta作为idp,配置如下:

3.1 依赖


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-saml2-service-provider</artifactId>
</dependency>

3.2 Spring Security 配置


@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.saml2Login(Customizer.withDefaults()); // 启用 SAML 登录
        return http.build();
    }
}

3.3 `application.yml` 配置

spring:
  security:
    saml2:
      relyingparty:
        registration:
           okta:
            assertingparty:
              metadata-uri: "https://idp.元数据.idp平台生成/metadata.xml"

4. SAML 登录流程

访问 http://localhost:8080/user
会经过一堆过滤器，发现未登陆以后会走到ExceptionTranslationFilter(异常拦截过滤器)
ExceptionTranslationFilter 发现是匿名用户，会使用DelegatingAccessDeniedHandler处理
DelegatingAccessDeniedHandler 又会委托authenticationEntryPoint 处理，saml会走到LoginUrlAuthenticationEntryPoint.commence处理
LoginUrlAuthenticationEntryPoint.commence 则会重定向到 /saml2/authenticate?registrationId={registrationId}
/saml2/authenticate?registrationId={registrationId} 经过 Saml2WebSsoAuthenticationRequestFilter 过滤器，会做相关处理
AbstractSaml2AuthenticationRequest authenticationRequest = this.authenticationRequestResolver.resolve(request); 解析出需要请求的参数
发送到 authenticationRequestUri 地址, 该地址则是idp生成的xml里的SingleSignOnService字段，也是 idp的地址
idp登陆认证通过后，会调用localhost:8080/login/saml2/sso/okta接口，此接口Saml2WebSsoAuthenticationFilter会去处理
Saml2WebSsoAuthenticationFilter 首先把saml的认证请求转化为Authentication,即spring_security的身份载体
BaseOpenSamlAuthenticationProvider.authenticate接口处理
successfulAuthentication(request, response, chain, authenticationResult); 登陆成功保存认证信息

luckLab

Understanding Closures in JavaScript

TypeScript Generics Explained

Python Decorators Demystified

Concurrency in Go

Mastering Async/Await in JavaScript

TypeScript Utility Types

Python's List Comprehensions

Error Handling in Go

JavaScript's Event Loop Explained

Advanced TypeScript: Conditional Types

3 Test

#test

Python's Generators and Yield

Go's Interfaces and Polymorphism

JavaScript's Prototypal Inheritance

TypeScript's keyof and Mapped Types

Python's Context Managers and the with Statement

Showing Off Blog Features

Theming

Code Blocks

Basic Markdown Elements

Images

Admonitions

Character Chats

Adding Your Own

Character Conversations

GitHub Cards

Emoji :star_struck:

LaTeX/KaTeX Math Support

HTML Elements

Fieldset with Inputs

Form with Labels

bochs调试

段描述符

段描述符

段基址: 32位宽 在16-31(16) 32-29(8) 56-63(8位)

段界限：即能寻址的最大范围(20位)(单位量)(字节/4kb)

g: 0 1字节 1 4k (2的20次方=1m) (1m*4k=4g)

s: 0 系统段(不是硬件需要的都不是系统段) 1 数据段

type: 4位 x r c a x(执行) r(读) c(一致性) a(是否访问过) a是cpu设置的(设置为0由cpu改)

dpl: 描述符权限级 2位 越小权限越大

p：段是否存在 在内存中是1 不在是0 如果是0,cup会抛异常

avl: 可用位

l: 1 64位代码段 32是0

D/B: d=0 16位 1 32位

G: 指定段界限的单位大小

gdt 段描述符表 用于存储段描述符(数组)(通过下标查找各个gd)

gdtR 即存放gdt的寄存器,存放gdt的首地址

选择子

段描述符缓冲寄存器

进程

进程

PCB 程序控制块(Process Control Block)

输入系统

页表机制

分页机制

逻辑地址 线性地址 和 物理地址

逻辑地址 ds里存放选择子,通过选择子找到段描述符，段描述符映射到段基地址 :偏移量 => 线性地址。

线性地址 关闭分页 ==> 物理地址 开启分页 -> 查页目录和页表 ->找到物理地址

开启分页后的逻辑 => 线性地址到物理地址

物理页帧和页项

一级页表

pte 页表项

二级页表

二级页表 页目录项

tss任务状态段

tss (Task State Segment) 任务状态段

tss描述符格式(tss描述符并不是tss)

elf可执行文件

elf 是目标文件格式 就是可执行文件

elf 文件头

elf 程序头结构体

elf文件示例

操作系统中断

中断按照事件来源分类:

外部中断:

内部中断

中断描述符表 idt interrupt descriptor table

中断门

段基址: 32位宽在16-31(16) 32-29(8) 56-63(8位)

dpl: 描述符权限级 2位越小权限越大

p：段是否存在在内存中是1 不在是0 如果是0,cup会抛异常

gdt 段描述符表用于存储段描述符(数组)(通过下标查找各个gd)

逻辑地址线性地址和物理地址

线性地址关闭分页 ==> 物理地址开启分页 -> 查页目录和页表 ->找到物理地址

二级页表页目录项

elf 是目标文件格式就是可执行文件

3.3 `application.yml` 配置

4. SAML 登录流程