Windows用户层使用指令操作内核程序执行指令! (3) 文件操作

原创 已于 2025-01-29 14:38:30 修改 · 383 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#windows

于 2025-01-28 17:27:48 首次发布

驱动开发中，文件操作是一个至关重要的环节。尽管在Windows系统中，“万物皆文件”的概念并不像在Linux中那样普遍，但文件操作仍然扮演着关键角色。例如，日记操作、强制删除文件等操作都离不开对文件系统的深入理解和操作能力。

通过亲自动手编写代码，可以有效提高自己的驱动开发水平。这不仅有助于加深对操作系统底层机制的理解，还能锻炼解决实际问题的能力。

文件定义:file.h

#pragma once
#include <ntifs.h>
#include "struct.h"
#include "Logging.h"

BOOLEAN MyFileExists(M_L ustrFilePath);
BOOLEAN MyCreateFile(M_L ustrFilePath);
BOOLEAN MyCreateFileFolder(M_L ustrFileFolderPath);
BOOLEAN MyDeleteFileOrFileFolder(M_L ustrFileName);

NTSTATUS WriteResponseCreate(UNICODE_STRING filePath);
NTSTATUS WriteResponseOpen(UNICODE_STRING filePath, PHANDLE fileHandle);
NTSTATUS WriteResponse(UNICODE_STRING response, HANDLE fileHandle);
NTSTATUS WriteResponseAppend(UNICODE_STRING response, HANDLE fileHandle);
NTSTATUS WriteResponseExists(UNICODE_STRING filePath, PBOOLEAN exists);
NTSTATUS WriteResponseDelete(UNICODE_STRING filePath);


NTSTATUS RetOpenFileHandle(UNICODE_STRING uDelFileName, PHANDLE pFileHandle);
NTSTATUS CallBackIrpCompleteionProc(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context);
NTSTATUS PassFileattribute(PFILE_OBJECT pFileObj);
NTSTATUS FsDeleteFile(PFILE_OBJECT pFileObj);
NTSTATUS IrpDeleteFileRun(UNICODE_STRING uDelFileName);

中间代码是我重写了一遍上面的代码使其更"好"用了一些,一般我们使用上面的,但是有一些文件操作可以看我的第一篇Windows用户层使用指令操作内核程序执行指令! (1) 日记文件,下面的代码暂时废弃,我在虚拟机中使用强删文件(IrpDeleteFileRun)时会导致不明错误:在资源管理器(explorer.exe)文件删了一刷新就会重新出现,在CMD中会直接显示拒绝访问

file.cpp

#include "file.h"

BOOLEAN MyFileExists(M_L ustrFilePath)
{
	NTSTATUS status = STATUS_SUCCESS;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	HANDLE hFile = NULL;

	UNICODE_STRING ustrFilePathTmp;
	RtlInitUnicodeString(&ustrFilePathTmp, ustrFilePath);

	// 初始化对象属性结构体
	InitializeObjectAttributes(&objectAttributes, &ustrFilePathTmp, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 打开文件
	status = ZwOpenFile(&hFile, FILE_READ_ATTRIBUTES, &objectAttributes, &iosb, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}
BOOLEAN MyCreateFile(M_L ustrFilePath)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	UNICODE_STRING ustrFilePathTmp;
	RtlInitUnicodeString(&ustrFilePathTmp, ustrFilePath);

	// 初始化对象属性结构体 FILE_SYNCHRONOUS_IO_NONALERT
	InitializeObjectAttributes(&objectAttributes, &ustrFilePathTmp, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 创建文件
	status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}

	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}
BOOLEAN MyCreateFileFolder(M_L ustrFileFolderPath)
{
	HANDLE hFile = NULL;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK iosb = { 0 };
	NTSTATUS status = STATUS_SUCCESS;

	UNICODE_STRING ustrFileFolderPathTmp;
	RtlInitUnicodeString(&ustrFileFolderPathTmp, ustrFileFolderPath);

	// 初始化对象属性结构体
	InitializeObjectAttributes(&objectAttributes, &ustrFileFolderPathTmp, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	// 创建目录 FILE_DIRECTORY_FILE
	status = ZwCreateFile(&hFile, GENERIC_READ, &objectAttributes, &iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_CREATE, FILE_DIRECTORY_FILE, NULL, 0);
	if (!NT_SUCCESS(status))
	{
		return FALSE;
	}
	// 关闭句柄
	ZwClose(hFile);

	return TRUE;
}
BOOLEAN MyDeleteFileOrFileFolder(M_L ustrFileName)
{
    NTSTATUS status = STATUS_SUCCESS;
    OBJECT_ATTRIBUTES objectAttributes = { 0 };
    UNICODE_STRING ustrFileNameTmp;
    RtlInitUnicodeString(&ustrFileNameTmp, ustrFileName);
    // 初始化属性
    InitializeObjectAttributes(&objectAttributes, &ustrFileNameTmp, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

    // 执行删除操作
    status = ZwDeleteFile(&objectAttributes);
    if (!NT_SUCCESS(status))
    {
        return FALSE;
    }

    return TRUE;
}

NTSTATUS WriteResponseCreate(UNICODE_STRING filePath)
{
	OBJECT_ATTRIBUTES objectAttributes;
	IO_STATUS_BLOCK ioStatusBlock;
	NTSTATUS status;
	HANDLE fileHandle = NULL;
	InitializeObjectAttributes(&objectAttributes, &filePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
	status = ZwCreateFile(&fileHandle, FILE_APPEND_DATA | SYNCHRONIZE, &objectAttributes, &ioStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
	if (status != STATUS_SUCCESS) {
		WriteLog("[LyKernelService] Failed to create file %wZ, status = 0x%x\n", filePath, status);
		return status;
	}
	if (fileHandle == NULL) {
		WriteLog("[LyKernelService] Failed to open file %wZ\n", filePath);
		return STATUS_INVALID_HANDLE;
	}
	return STATUS_SUCCESS;
}
NTSTATUS WriteResponseOpen(UNICODE_STRING filePath, PHANDLE fileHandle)
{
    OBJECT_ATTRIBUTES objAttr;
    InitializeObjectAttributes(&objAttr, &filePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    IO_STATUS_BLOCK ioStatus;
    NTSTATUS status = STATUS_SUCCESS;
    HANDLE fileHandleTmp = NULL;
    status = ZwCreateFile(&fileHandleTmp, FILE_APPEND_DATA | SYNCHRONIZE, & objAttr, & ioStatus, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
    if (status != STATUS_SUCCESS) {
        WriteLog("[LyKernelService] Failed to open file %wZ, status = 0x%x\n", filePath, status);
        return status;
    }
    if (fileHandleTmp == NULL) {
        WriteLog("[LyKernelService] Failed to open file %wZ\n", filePath);
        return STATUS_INVALID_HANDLE;
    }
    *fileHandle = fileHandleTmp;
    return STATUS_SUCCESS;
}
NTSTATUS WriteResponse(UNICODE_STRING response, HANDLE fileHandle)
{
	IO_STATUS_BLOCK ioStatusBlock;
	NTSTATUS status;
	status = ZwWriteFile(fileHandle, NULL, NULL, NULL, &ioStatusBlock, response.Buffer, response.Length / 2, NULL, NULL);
	if (status != STATUS_SUCCESS) {
		WriteLog("[LyKernelService] Failed to write to file, status = 0x%x\n", status);
	}
	ZwClose(fileHandle);
	return status;
}
NTSTATUS WriteResponseAppend(UNICODE_STRING response, HANDLE fileHandle)
{
	NTSTATUS status;
	IO_STATUS_BLOCK ioStatusBlock;
	status = ZwWriteFile(fileHandle, NULL, NULL, NULL, &ioStatusBlock, response.Buffer, response.Length / 2, NULL, NULL);
	if (status != STATUS_SUCCESS) {
		WriteLog("[LyKernelService] Failed to write to file, status = 0x%x\n", status);
	}
	return status;
}
NTSTATUS WriteResponseExists(UNICODE_STRING filePath, PBOOLEAN exists)
{
    NTSTATUS status = STATUS_SUCCESS;
    OBJECT_ATTRIBUTES objectAttributes = { 0 };
    IO_STATUS_BLOCK ioStatusBlock = { 0 };
    HANDLE fileHandle = NULL;
    InitializeObjectAttributes(&objectAttributes, &filePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    status = ZwOpenFile(&fileHandle, FILE_READ_ATTRIBUTES, &objectAttributes, &ioStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT);
    if (status != STATUS_SUCCESS) {
        *exists = FALSE;
        return status;
    }
    if (fileHandle == NULL) {
        *exists = FALSE;
        return STATUS_INVALID_HANDLE;
    }
    *exists = TRUE;
    ZwClose(fileHandle);
    return STATUS_SUCCESS;
}
NTSTATUS WriteResponseDelete(UNICODE_STRING filePath)
{
    NTSTATUS status = STATUS_SUCCESS;
    OBJECT_ATTRIBUTES objectAttributes = { 0 };
    IO_STATUS_BLOCK ioStatusBlock = { 0 };
    HANDLE fileHandle = NULL;
    InitializeObjectAttributes(&objectAttributes, &filePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    status = ZwOpenFile(&fileHandle, FILE_DELETE_CHILD, &objectAttributes, &ioStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT);
    if (status != STATUS_SUCCESS) {
        WriteLog("[LyKernelService] Failed to open file %wZ, status = 0x%x\n", filePath, status);
        return status;
    }
    if (fileHandle == NULL) {
        WriteLog("[LyKernelService] Failed to open file %wZ\n", filePath);
        return STATUS_INVALID_HANDLE;
    }
    status = ZwDeleteFile(&objectAttributes);
    if (status != STATUS_SUCCESS) {
        WriteLog("[LyKernelService] Failed to delete file %wZ, status = 0x%x\n", filePath, status);
        return status;
    }
    ZwClose(fileHandle);
    return STATUS_SUCCESS;
}

NTSTATUS RetOpenFileHandle(UNICODE_STRING uDelFileName, PHANDLE pFileHandle)
{

    NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
    IO_STATUS_BLOCK iostu;
    HANDLE hFileHandle = 0;
    if (pFileHandle == NULL)
        return STATUS_UNSUCCESSFUL;
    if (KeGetCurrentIrql() > PASSIVE_LEVEL)
        return 0;

    if (uDelFileName.Length < 0 || uDelFileName.MaximumLength < 0)
    {
        return 0;
    }


    OBJECT_ATTRIBUTES ObjAttribute;
    ObjAttribute.ObjectName = &uDelFileName;
    ObjAttribute.SecurityDescriptor = NULL;
    ObjAttribute.SecurityQualityOfService = NULL;
    ObjAttribute.Attributes = OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE;
    ObjAttribute.Length = sizeof(OBJECT_ATTRIBUTES);

    /*  InitializeObjectAttributes(
          &ObjAttribute,
          &uDelFileName,
          OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
          NULL, NULL);*/

    ntStatus = IoCreateFile(&hFileHandle,
        FILE_READ_ATTRIBUTES,
        &ObjAttribute,
        &iostu,
        0,
        FILE_ATTRIBUTE_NORMAL,
        FILE_SHARE_DELETE,
        FILE_OPEN,
        0,
        NULL,
        0,
        CreateFileTypeNone,
        NULL,
        IO_NO_PARAMETER_CHECKING);

    *pFileHandle = hFileHandle;
    return ntStatus;
}
NTSTATUS CallBackIrpCompleteionProc(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{

    //操作系统会设置这个回调
    Irp->UserIosb->Status = Irp->IoStatus.Status;
    Irp->UserIosb->Information = Irp->IoStatus.Information;
    KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, FALSE);

    IoFreeIrp(Irp);
    return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS PassFileattribute(PFILE_OBJECT pFileObj)
{
    /*
    1.申请IRP,初始化IRP
    2.初始化同步事件,以及设置回调.
    3.设置文件属性为默认
    4.发送IRP
    */
    PDEVICE_OBJECT pNextDeviceObj = NULL;
    PIRP pAllocIrp = NULL;
    KEVENT IrpSynEvent = { 0 }; //Irp同步需要的事件同步
    FILE_BASIC_INFORMATION fileBasciInfo = { 0 };
    IO_STATUS_BLOCK iostu;
    PIO_STACK_LOCATION IrpStack;
    //通过文件对象.获取其设备对象指针
    pNextDeviceObj = IoGetRelatedDeviceObject(pFileObj);
    if (pNextDeviceObj == NULL)
        return STATUS_UNSUCCESSFUL;

    //通过设备对象指针.确定申请的IRP的大小,注意在完成设置里面进行释放.
    pAllocIrp = IoAllocateIrp(pNextDeviceObj->StackSize, TRUE);
    if (pAllocIrp == NULL)
        return STATUS_UNSUCCESSFUL;

    //初始化Irp

    //设置为自动,设置为无信号.
    KeInitializeEvent(&IrpSynEvent, SynchronizationEvent, FALSE);

    fileBasciInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;
    pAllocIrp->AssociatedIrp.SystemBuffer = &fileBasciInfo;
    pAllocIrp->UserIosb = &iostu;
    pAllocIrp->UserEvent = &IrpSynEvent;
    pAllocIrp->Tail.Overlay.OriginalFileObject = pFileObj;
    pAllocIrp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();

    //获取下层堆栈.进行设置.

    //IrpStack  = 
    IrpStack = IoGetNextIrpStackLocation(pAllocIrp);
    IrpStack->MajorFunction = IRP_MJ_SET_INFORMATION;
    IrpStack->DeviceObject = pNextDeviceObj;
    IrpStack->FileObject = pFileObj;
    IrpStack->Parameters.SetFile.Length = sizeof(FILE_BASIC_INFORMATION);
    IrpStack->Parameters.SetFile.FileObject = pFileObj;
    IrpStack->Parameters.SetFile.FileInformationClass = FileBasicInformation;

    //设置完成例程
    IoSetCompletionRoutine(pAllocIrp, CallBackIrpCompleteionProc, &IrpSynEvent, TRUE, TRUE, TRUE);


    //发送IRP
    IoCallDriver(pNextDeviceObj, pAllocIrp);
    //等待完成.

    KeWaitForSingleObject(&IrpSynEvent, Executive, KernelMode, TRUE, NULL);

    return STATUS_SUCCESS;
}
NTSTATUS FsDeleteFile(PFILE_OBJECT pFileObj)
{
    /*
  1.申请IRP,初始化IRP
  2.初始化同步事件,以及设置回调.
  3.设置文件属性为默认
  4.发送IRP

  核心:
    核心是设置 FileObject中的域.进而删除正在运行中的文件

  */
    PDEVICE_OBJECT pNextDeviceObj = NULL;
    PIRP pAllocIrp = NULL;
    KEVENT IrpSynEvent = { 0 }; //Irp同步需要的事件同步
    FILE_DISPOSITION_INFORMATION     fileBasciInfo = { 0 };  //注意此位置.已经变化为 FILE_DISPOSITION_INFORMATION
    IO_STATUS_BLOCK iostu;
    PIO_STACK_LOCATION IrpStack;

    PSECTION_OBJECT_POINTERS pFileExe;  //注意此属性要设置为0.欺骗系统进行删除
    //通过文件对象.获取其设备对象指针
    pNextDeviceObj = IoGetRelatedDeviceObject(pFileObj);
    if (pNextDeviceObj == NULL)
        return STATUS_UNSUCCESSFUL;

    //通过设备对象指针.确定申请的IRP的大小,注意在完成设置里面进行释放.
    pAllocIrp = IoAllocateIrp(pNextDeviceObj->StackSize, TRUE);
    if (pAllocIrp == NULL)
        return STATUS_UNSUCCESSFUL;

    //初始化Irp

    //设置为自动,设置为无信号.
    KeInitializeEvent(&IrpSynEvent, SynchronizationEvent, FALSE);

    fileBasciInfo.DeleteFile = TRUE;        //设置标记为删除
    pAllocIrp->AssociatedIrp.SystemBuffer = &fileBasciInfo;
    pAllocIrp->UserIosb = &iostu;
    pAllocIrp->UserEvent = &IrpSynEvent;
    pAllocIrp->Tail.Overlay.OriginalFileObject = pFileObj;
    pAllocIrp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();

    //获取下层堆栈.进行设置.

    //IrpStack  = 
    IrpStack = IoGetNextIrpStackLocation(pAllocIrp);
    IrpStack->MajorFunction = IRP_MJ_SET_INFORMATION;
    IrpStack->DeviceObject = pNextDeviceObj;
    IrpStack->FileObject = pFileObj;
    IrpStack->Parameters.SetFile.Length = sizeof(FILE_DISPOSITION_INFORMATION);
    IrpStack->Parameters.SetFile.FileObject = pFileObj;
    IrpStack->Parameters.SetFile.FileInformationClass = FileDispositionInformation;

    //设置完成例程
    IoSetCompletionRoutine(pAllocIrp, CallBackIrpCompleteionProc, &IrpSynEvent, TRUE, TRUE, TRUE);

    //删除正在运行中的文件.

    pFileExe = pFileObj->SectionObjectPointer;
    pFileExe->DataSectionObject = 0;
    pFileExe->ImageSectionObject = 0;
    //发送IRP
    IoCallDriver(pNextDeviceObj, pAllocIrp);
    //等待完成.

    KeWaitForSingleObject(&IrpSynEvent, Executive, KernelMode, TRUE, NULL);

    return STATUS_SUCCESS;
}
NTSTATUS IrpDeleteFileRun(UNICODE_STRING uDelFileName)
{
    NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
    /*
    1.首先通过发送IRP去掉文件的属性
    2.设置文件属性为删除.进行发送IRP强删文件.
    */
    HANDLE hFileHandle = { 0 };
    PFILE_OBJECT  pFileObject = NULL;
    //sep1 : OpenFile Get File Handle
    ntStatus = RetOpenFileHandle(uDelFileName, &hFileHandle);

    if (!NT_SUCCESS(ntStatus))
    {
        WriteLog("[LyKernelService] Failed to open file %wZ, status = 0x%x\n", uDelFileName, ntStatus);
        goto ExitAnRelease;
    }
    //sep2:  Chang File Handle to FileObject

    ntStatus = ObReferenceObjectByHandle(
        hFileHandle,
        GENERIC_ALL,
        *IoFileObjectType,
        KernelMode,
        (PVOID*)&pFileObject,
        NULL);
    if (!NT_SUCCESS(ntStatus))
    {
        WriteLog("[LyKernelService] Failed to get file object, status = 0x%x\n", ntStatus);
        goto ExitAnRelease;
    }

    //setp 3:  Pass File Atribute
    ntStatus = PassFileattribute(pFileObject);
    if (!NT_SUCCESS(ntStatus))
    {
        WriteLog("[LyKernelService] Failed to pass file attribute, status = 0x%x\n", ntStatus);
        goto ExitAnRelease;
    }

    //setp 4: Send Irp DeleteFile
    ntStatus = FsDeleteFile(pFileObject);
    if (!NT_SUCCESS(ntStatus))
    {
        WriteLog("[LyKernelService] Failed to send delete file irp, status = 0x%x\n", ntStatus);
        goto ExitAnRelease;
    }
ExitAnRelease:

    if (pFileObject != NULL)
        ObDereferenceObject(pFileObject);
    if (hFileHandle != NULL)
        ZwClose(hFileHandle);

    return ntStatus;
}

注意在使用file.h代码时一定要先使用ZwClose()对已获得的文件句柄释放掉(或者自己写一个强制解锁文件),否则会打印"0xC0000043"错误,即"STATUS_SHARING_VIOLATION"错误.对应代码其实不难,主要是可以根据Microsoft提供的文档进行开发

Windows用户层使用指令操作内核程序执行指令! (4) 驱动加密算法

使用Windbg分析dump文件定位软件异常的方法与操作步骤
dvlinker的技术专栏
03-04 7万+
本文详细讲述了使用Windbg分析dump文件的一般步骤与诸多细节，并给出了一个实战分析实例，有一定的实战参考价值。
ARM芯片、内核、架构、指令集的联系与区别
热门推荐
zhizhuan3361的博客
05-21 2万+
问题1：单片机和CPU的区别在嵌入式领域ARM芯片和CPU有什么区别呢？其实随着嵌入式科技的不断发展，单片机（像ARM芯片）和CPU的界限越来越模糊，我们暂且可以认为ARM芯片就是一个CPU，或者暂且认为单片机就相当于一个CPU。问题2：什么是ARM芯片凡是采用ARM内核的芯片（或者凡是采用ARM内核的CPU）都是ARM芯片。例如高通的OMAP36X0系列处理器（Droid 2和Droid X用的...
一文彻底分清ARM架构、内核、指令集等相关概念
闪耀大叔的博客
04-28 3389
任何学习嵌入式/单片机的朋友都绕不开ARM，但初学者总是对ARM架构、内核、指令集等相关概念不够清晰或者混淆，本文帮助入门的朋友彻底弄清楚。
操作系统浅谈（二）
王魂风气的博客
06-23 587
简单来说，指令就是处理器CPU能识别、执行的最基本命令，比如：加法指令就是让CPU进行加法运算。① 特权指令如内存清零指令，不允许用户程序使用② 非特权指令如普通的运算指令① 用户态此时CPU只能执行非特权指令② 核心态特权指令、非特权指令都可以执行用程序状态字寄存器中的某标志位来标识当前处理器处于什么状态。如0为用户态，1为核心态。① 内核程序操作系统的内核程序时系统的管理者，既可以执行特权指令，也可以执行非特权指令，运行在核心态。② 应用程序为了保证系统能安全运行，普通应用程序只能执行非特权指令，运行在
在linux系统中显示内核模块的命令,Linux内核模块管理命令
weixin_33256071的博客
05-03 2075
1、insmod命令在Linux系统下，insmod命令用于将给定的模块加载到内核中去，Linux系统有许多功能是通过模块的方式，在需要时才载入kernel，这样做可以使kernel较为精简，进而提高效率，这类可载入的模块，通常是设备驱动程序。(1)命令语法insmod(选项)(参数)(2)常用选项说明-f：不检查目前kernel版本与模块编译时的kernel版本是否一致，强制将模块载入。-k：将...
Linux内核基础与常用命令总结
Java技术江湖
07-04 8095
Linux操作系统 Linux操作系统博大精深，其中对线程，IO，文件系统等概念的实现都很有借鉴意义。 文件系统和VFS 文件系统的inode上面讲过了。VFS主要用于屏蔽底层的不同文件系统，比如接入网络中的nfs文件系统，亦或是windows文件系统，正常情况下难以办到，而vfs通过使用IO操作的posix规范来规定所有文件读写操作，每个文件系统只需要实现这些操作就可以接入VFS，不需...
Linux_kernel汇编指令05
qq_45882170的博客
09-04 885
用来检测stack是否overflow，可以把stack的最低端写入sl寄存器中，这样处理后，如果sp指向的地址低于sl寄存器里面的值时，就会触发栈溢出的错误。我们可以使用桟帧（stack frame）来区分，桟帧就是一个函数所使用的stack的一部分，所有函数的桟帧穿起来就是一个完整的栈，桟帧的两个边界分别是由fp和sp来限定。在函数的调用过程中，通常使用栈帧结构，也就是sp指针总是指向程序的顶端，同时设置fp来保存当前函数在栈上的基地址。Rn基址寄存器，存储传送数据的起始地址(Rn不能是R15)
Windows用户层使用指令操作内核程序执行指令! (总述)
systemnb的博客
01-28 870
这个项目不仅可以帮助用户实现读写任意内存地址的操作，还能让用户在文件管理上拥有更高的自由度（例如强制隐藏、删除、创建文件等），甚至在进程管理上也能做到“当老大”的程度。- `driver.cpp`: 这是驱动程序的主入口文件，负责启动整个驱动程序的运行流程，包括初始化各个模块、进入主循环等待命令等。- `Logging.cpp`: 实现日志记录功能，包括日志的初始化、日志信息的格式化和输出等。- `command.cpp`: 实现命令的具体处理逻辑，根据接收到的命令执行相应的操作。
操作系统——用户态与内核态、同步与异步、阻塞与阻塞
longool的博客
05-28 1527
计算机系统中，通常 CPU 执行两种不同性质的程序代码：一种是操作系统内核程序（管理程序）；另一种是用户自编程序（即系统外层的应用程序，或简称 “应用程序”）。CPU 运行这两种不同性质的程序，就是操作系统中最基本的两种运行模式：用户态和内核态。先来说一些废话程序执行目的就是操作计算机中的各种硬件资源，每个程序最终都会编程二进制语言来操作硬件，从而实现某种具体功能。这样一说，好像可以不用操作系统，每个程序自己就是操作系统了。行吗？肯定不行啊。应用程序大多是高级语言编写的，你会将高级语言编译成二进制语言吗？
精简指令集_基于risc5指令集的操作系统内核.zip
最新发布
09-05
此外，RISC-V指令集支持多种执行模式，包括机器模式、监督模式和用户模式，使得内核可以更好地进行权限控制和系统保护。 在内核设计方面，为了保证操作系统的稳定性，需要实现一套完整的中断和异常处理机制。RISC-V...
操作系统实验——用户态与内核态
04-18
用户态与内核态是操作系统中的两个基本概念，分别代表CPU执行指令的不同权限级别。在用户态（User Mode）下，CPU仅能执行非特权指令，而内核态（Kernel Mode）允许CPU执行所有指令，包括特权指令。通常，用户态是...
硬核思路看安全--内核篇：基础知识（一）常见CPU架构和指令集
Uloboros的博客
03-01 1110
网络安全这个方向有太多东西可以讨论，从最常见的web安全、通信链路安全、协议安全、无线安全、系统安全、物联网安全、移动安全以及细分出来的密码学、可穿戴设备安全、车联网安全等等，完全是一颗拥有无数分支、枝繁叶茂的参天大树。所以掌握事务的本质就变得很重要，也就是从万变中找到不变！，那么对于所有计算机系统和所有常见的基于计算机系统的设备来说什么是本质呢？是二进制？是CPU架构？是硬件体系？还是各种操作系统？一切尽在：硬核思路看安全--内核篇！
编译内核的相关知识
qq_46518045的博客
01-19 1143
1,在PC端搭建环境。（ubantu） 2,树莓派等芯片带操作系统的启动过程 C51,STM32(裸机)用C直接操控底层寄存器实现相关业务。 业务流程型的裸机代码。 3，带有操作系统的（X86,intel,windows） 启动过程：电源->bios芯片->windows内核->C,D盘->启动程序 嵌入式产品：树莓派，mini2440，mini6410,nanopi,海思，RK(瑞芯微) 启动过程： 电源-》BootLoader（引导操作系统启动）-》Linux内核-》文件系统
查看Linux系统版本内核命令大全
eli的博客
09-26 7629
目录 命令一：查看当前系统发行版本详细信息 命令二：查看当前系统内核信息 命令三：查看当前系统版本信息 命令四：查看CPU相关信息 命令五：查看系统位数 Linux系统内核、发行版本有很多，那么如何查看当前Linux系统的内核信息、Linux系统发行版本等信息呢？Linux百科网分享查询Linux系统详细信息的方法： 命令一：查看当前系统发行版本详细信息 LSB是Linux Standard Base的缩写，lsb_release命令用来显示LSB和特定版本的相关信息 执行命令：lsb_
kernel的启动参数
qsycn的专栏
05-25 2311
概述内核引导参数大体上可以分为两类：一类与设备无关、另一类与设备有关。内核源码树下的 Documentation/kernel-parameters.txt 文件列出了所有可用的引导参数，并指明了处理每个参数的具体文件。注意：对于模块而言，引导参数只能用于直接编译到核心里的模块，格式是使用"模块名.参数=值"模式指定，比如：usbcore.blinkenlights=1 。动态加载的模块可以在 m
linux内核编译常见指令介绍
风之恋
09-01 578
这次主要说一下Linux(RedHat9)内核的升级 [主版本].[次版本].[修订版本]-[附版本] 2 4 20 8  1. 如果次版本是奇数的话,例如2.3, 2.5 等等,那表示他是一个『测试性质功能的核心版本』, 这种核心通常是在推出稳定版本的核心之前,用来给developer ( 核心维护更新测试者！) 测试用的！ 虽然功能较为强大,但是是属于测试性质,可能会有些许的bug
linux 内核相关命令
duanbeibei的专栏
12-26 575
1. insmod:  插入模块 2. dmesg:  查看内核输出信息 3. modinfo:  查看模块信息，包括其依赖性 4. fbset:  frame buffer set
【Linux】查看内核命令
hello__的博客
06-20 7744
cat /proc/version uname -r uname -a
几种常见的内核配置命令详解
临风笑的专栏
09-22 2381
常见的几种配置方式： 为了完成内核的配置，必须切换到root用户，然后转入内核源码目录(就是你下载新内核的目录)： #cd /usr/src/linux/linux-2.6.38 然后执行下面命令之一: #make config #make oldconfig #make menuconfig #make gconfig #make defconfig #make all
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值