精华内容
下载资源
问答
  • 如何选择安装硬盘请参考这个文章:不是小白:WD-black SN750 西数黑盘安装好硬盘后就是怎么这个硬盘像其他硬盘一样正常使用了,接下来是不同情况下的操作方法:加装要求:A:必须有多余空闲的硬盘接口(就是没有插...

    6901d54f8da754f6cbfd45be0ee91418.png

    如何选择安装硬盘请参考这个文章:不是小白:WD-black SN750 西数黑盘

    安装好硬盘后就是怎么让这个硬盘像其他硬盘一样正常使用了,接下来是不同情况下的操作方法:

    加装要求:

    A:必须有多余空闲的硬盘接口(就是没有插上硬盘的接口,怎么查看请阅读上面地址的文章)如果不确定,需要拆机查看

    B:已经加装完毕后,电脑内必须至少有一个硬盘有系统才能正常开机,任何硬盘都没有系统无法开机

    已经连接好后就是让他在电脑里面显示,接下来就是“分区”,因为是加装非重装,所以在开机后进入系统设置分区就可以了

    分区操作的两种方法:

    第一种,文件管理器中,右击“此电脑”- 选择“管理”-点击“磁盘管理”

    483518c80388abec98ae2d356722266d.png

    639608b87c325540da7c3728c3103da6.png

    然后开始分区,如下图所示,新安装的硬盘在左侧会显示“未知”需要初始化后才能使用,点击新硬盘后“初始化磁盘”窗口会自动弹出,在这里选择GPT,然后点击确定就可以了(如果没有自动弹出窗口,鼠标移动到新硬盘左侧后右击,选择“初始化”就会出现这个窗口了)

    ced86ec6d0c8f910db81e5217bb6f5d6.png

    初始化完成后,点击右侧,然后右击-选择“新建简单卷”

    fd1726c79b2210c653f6b516100f6e09.png

    704e9ceed46ff8942f8aacd2e4701a7e.png

    请注意,这里默认数值是最大容量,也就是一个区,如果要分两个或者多个区,简单卷大小数值请按照需求自行定义,比如要先分100G,数值就是100*1024=102400,数值填102400即可,点击下一步后出现下一界面,红框所示可默认可自定义

    d356df33bd0822b3ce56f9a947c417e0.png

    点击下一步后出现如下界面,“分配单元大小”需设置为“4096”(设置完成后是4K对齐)

    然后设置卷标(也就是分区名字)可默认可自定义

    4976aca716e70790089356a4466ce451.png

    点击下一步后加入结束页面,点击完成即可

    62751312db861bac9e61a8201b219b22.png

    请注意,这是分的第一个区,分完后,后面还会显示未分配的容量,按照上述方法重新分配即可

    e10f68514407714e3aec7c1319c29f4b.png

    部分系统会出现设置不成功的情况,所以需要第二种分区方法:

    下载DG分区软件后使用分区软件进行分区

    8b86f5ef2495dc25a4ab65b3a6f874b2.png

    加装教程步骤以完毕,如果分区中出现其他问题,请询问您购买硬盘的服务商或者客服咨询

    重装硬盘要求:

    展开全文
  • C程序的内存层次

    2016-12-05 14:44:40
    一个C程序的内存分布可以分为五大部分:代码段、初始化的数据段、未初始化的数据段、栈、堆。注意这里我们讨论的是,在运行一个C编写的二进制程序时,内存是如何分布的。有一些前提知识需要强调。我们都知道,二进制...

    一个C程序的内存分布可以分为五大部分:代码段、初始化的数据段、未初始化的数据段、栈、堆。

    memory layout

    注意这里我们讨论的是,在运行一个C编写的二进制程序时,内存是如何分布的。有一些前提知识需要强调。我们都知道,二进制程序原本存在硬盘上,要执行时,会加载进入内存。因为操作系统的作用,虽然一个计算机的内存可能只有4GB,但是操作系统会让每一个程序都以为自己独占了这所有的空间,那么这个时候每一个程序处理的内存地址就是一个虚拟的地址,而不是真实地址。现在我们看见的这个图,就是一个从高地址到低地址的整个4GB空间,所以最上面是0xFFFFFF,最下面是0x000000。

    text部分,也就是代码段,存放的是将要执行的机器指令。代码段通常是只读的,不可写入。

    已经初始化的数据段,通常也就是我们说的data segment。数据段这里存放了很多虚拟地址,指向程序员在程序中初始化了的全局变量和静态变量。这一部分是可写的。这一块其实可以也分为只读的和可读可写的两块。比如一个全局字符串变量定义:char *string = “hello world”,会把hello world字符串放在只读区域,而string指针则放在可读写的区域。

    未初始化的数据段,通常被称为BSS段。这里存放的数据在程序开始执行之前被内核初始化为0。这部分位于数据段后面,包括了所有未初始化或者初始化为0的全局变量和静态变量。例如一个定义:static int i,就会放在BSS段。

    栈和堆通常相对生长。栈区域从高地址开始,向低地址生长,是LIFO模式。但是只是x86是这样,有些体系结构是反向生长的!栈指针(SP)用来追踪栈顶,如果入栈或出栈的值,SP的值就会改变。栈中为一个函数调用存入值的总和,叫做栈帧。栈帧最少过也有一个成员,就是返回地址。函数调用时,相关的参数、局部变量、返回地址都会存在栈里。所以C中可以实现递归函数,每次一个递归函数调用自己的时候,就会产生一个新的栈帧,不会影响这个函数之前的实例。

    堆使用来动态分配内存的。堆紧接着BSS段开始,从低地址向高地址生长。堆的区域是由malloc、realloc、free函数来处理的,这几个函数可能使用brk和sbrk这样的系统调用来调整大小(也可能是使用mmap实现对不连续的虚拟内存的映射)。堆区域被所有共享库共享,可以在一个进程里动态加载模块。

    展开全文
  • BIOS依次寻找其他设备的BIOS并且他们初始化自检 开始检测CPU,内存,光盘,硬盘,光驱,串口,并口,软驱即插即用设备 进入系统引导 上面的过程可以抽象为如下: 客户端只是想要发出命令或者请求,...

    1.场景模拟 

    请用软件模拟开机过程
    按下启动按钮
    然后电源供电
    主板开始加电自检
    BIOS依次寻找其他设备的BIOS并且让他们初始化自检
    开始检测CPU,内存,光盘,硬盘,光驱,串口,并口,软驱即插即用设备
    进入系统引导


    上面的过程可以抽象为如下:
    客户端只是想要发出命令或者请求,不关心请求的真正接受者是谁,也不关心具体如何实现,而且同一个请求的动作可以有不同的请求内容,当然具体的处理功能也不一样。请问如何实现呢?

    2.使用命令模式来解决问题

    2.1命令模式定义

    将一个请求封装为一个对象,从而是你可以用不同的请求对客户进行参数化,队请求排队或者请求日志,以及支持可撤销的操作。

    2.2命令模式的结构图

    在命令模式中,会定义一个命令的接口,用来约束所有的命令对象,然后提供具体的命令实现,每个命令实现对象是对客户端某个请求的封装,对应于机箱上的按钮,一个机箱上可以有很多按钮,也就相当于会有多个具体的命令实现对象。在命令模式中,命令对象并不知道如何处理命令,会有相应的接受者对象来真正执行命令。


     

    3.命令模式示例代码详解

    3.1命令接口,声明执行的操作

    package demo12.command.example1;
    /**
     * 命令接口,声明执行的操作
     */
    public interface Command {
    	/**
    	 * 执行命令对应的操作
    	 */
    	public void execute();
    }

    3.2具体的命令实现对象

    package demo12.command.example1;
    /**
     * 具体的命令实现对象
     */
    public class ConcreteCommand implements Command {
    	/**
    	 * 持有相应的接受者对象
    	 */
    	private Receiver receiver = null;
    	/**
    	 * 示意,命令对象可以有自己的状态
    	 */
    	private String state;
    	/**
    	 * 构造方法,传入相应的接受者对象
    	 * @param receiver 相应的接受者对象
    	 */
    	public ConcreteCommand(Receiver receiver){
    		this.receiver = receiver;
    	}
    	
    	public void execute() {
    		//通常会转调接受者对象的相应方法,让接受者来真正执行功能
    		receiver.action();
    	}
    }

    3.3接收者对象

    package demo12.command.example1;
    /**
     * 接收者对象
     */
    public class Receiver {
    	/**
    	 * 示意方法,真正执行命令相应的操作
    	 */
    	public void action(){
    		//真正执行命令操作的功能代码
    	}
    }

    3.4调用者对象

    package demo12.command.example1;
    /**
     * 调用者
     */
    public class Invoker {
    	/**
    	 * 持有命令对象
    	 */
    	private Command command = null;
    	/**
    	 * 设置调用者持有的命令对象
    	 * @param command 命令对象
    	 */
    	public void setCommand(Command command) {
    		this.command = command;
    	}
    	/**
    	 * 示意方法,要求命令执行请求
    	 */
    	public void runCommand() {
    		//调用命令对象的执行方法
    		command.execute();
    	}
    }

    3.5客户端使用

    package demo12.command.example1;
    
    
    public class Client {
    	/**
    	 * 示意,负责创建命令对象,并设定它的接受者
    	 */
    	public void assemble() {
    		// 创建接受者
    		Receiver receiver = new Receiver();
    		// 创建命令对象,设定它的接收者
    		Command command = new ConcreteCommand(receiver);
    		// 创建Invoker,把命令对象设置进去
    		Invoker invoker = new Invoker();
    		invoker.setCommand(command);
    	}
    }

    4.使用命令模式来实现场景中的问题

    4.1代码示例结构图

    机箱上的按钮就相当于命令对象
    机箱相当于调用者
    主板相当于接受者对象
    命令对象持有一个接受者对象,相当于给机箱的按钮连了一根连接线
    当机箱上的按钮被按下的时候,机箱就把这个命令通过连接线发送出去。
     

    4.2定义主板接口

    package demo12.command.example2;
    /**
     * 主板的接口
     */
    public interface MainBoardApi {
    	/**
    	 * 主板具有能开机的功能
    	 */
    	public void open();
    }

    4.3技嘉主板

    package demo12.command.example2;
    /**
     * 技嘉主板类,开机命令的真正实现者,在Command模式中充当Receiver
     */
    public class GigaMainBoard implements MainBoardApi{
    	/**
    	 * 真正的开机命令的实现
    	 */
    	public void open(){
    		System.out.println("技嘉主板现在正在开机,请等候");
    		System.out.println("接通电源......");
    		System.out.println("设备检查......");
    		System.out.println("装载系统......");
    		System.out.println("机器正常运转起来......");
    		System.out.println("机器已经正常打开,请操作");
    	}
    }

    4.4命令接口

    package demo12.command.example2;
    /**
     * 命令接口,声明执行的操作
     */
    public interface Command {
    	/**
    	 * 执行命令对应的操作
    	 */
    	public void execute();
    }

    4.5命令的具体实现

    package demo12.command.example2;
    /**
     * 开机命令的实现,实现Command接口,
     * 持有开机命令的真正实现,通过调用接收者的方法来实现命令
     */
    public class OpenCommand implements Command{
    	/**
    	 * 持有真正实现命令的接收者——主板对象
    	 */
    	private MainBoardApi mainBoard = null;
    	/**
    	 * 构造方法,传入主板对象
    	 * @param mainBoard 主板对象
    	 */
    	public OpenCommand(MainBoardApi mainBoard) {
    		this.mainBoard = mainBoard;
    	}
    	
    	public void execute() {
    		//对于命令对象,根本不知道如何开机,会转调主板对象
    		//让主板去完成开机的功能
    		this.mainBoard.open();
    	}
    }

    4.6提供机箱

    package demo12.command.example2;
    /**
     * 机箱对象,本身有按钮,持有按钮对应的命令对象
     */
    public class Box {
    	/**
    	 * 开机命令对象
    	 */
    	private Command openCommand;
    	/**
    	 * 设置开机命令对象
    	 * @param command 开机命令对象
    	 */
    	public void setOpenCommand(Command command){
    		this.openCommand = command;
    	}
    	/**
    	 * 提供给客户使用,接受并相应用户请求,相当于按钮被按下触发的方法
    	 */
    	public void openButtonPressed(){
    		//按下按钮,执行命令
    		openCommand.execute();
    	}
    }

    4.7客户端使用

    package demo12.command.example2;
    
    
    public class Client {
    	public static void main(String[] args) {
    		//1:把命令和真正的实现组合起来,相当于在组装机器,
    		//把机箱上按钮的连接线插接到主板上。
    		MainBoardApi mainBoard = new GigaMainBoard();
    		OpenCommand openCommand = new OpenCommand(mainBoard);
    		//2:为机箱上的按钮设置对应的命令,让按钮知道该干什么
    		Box box = new Box();
    		box.setOpenCommand(openCommand);
    		
    		//3:然后模拟按下机箱上的按钮
    		box.openButtonPressed();
    	}
    }

    5.命令模式讲解

    5.1命令模式的关键

    就是把请求也封装为对象
    命令模式中通常会有一个命令的组装者,用它来维护虚实现和真实实现之间的关系。
    并且发起请求的对象和真正实现的对象是解耦的。

    5.2命令模式的调用顺序图如下

     

    6.命令的参数化配置

    可以用不同的命令对象,去参数化配置客户的请求。
    实际上也很简单,举个例子:比如添加一个重启功能。
    那么就在MainBoardApi上添加一个reset()函数即可,然后再重新写一个ResetCommand实现Command,当然box中也要添加一个重启的函数resetButtonPressed()就行啦。那么客户端调用就如下

    package demo12.command.example3;
    
    
    public class Client {
    	public static void main(String[] args) {
    		//1:把命令和真正的实现组合起来,相当于在组装机器,
    		//把机箱上按钮的连接线插接到主板上。
    		MainBoardApi mainBoard = new GigaMainBoard();
    		//创建开机命令
    		OpenCommand openCommand = new OpenCommand(mainBoard);
    		//创建重启机器的命令
    		ResetCommand resetCommand = new ResetCommand(mainBoard);
    		
    		//2:为机箱上的按钮设置对应的命令,让按钮知道该干什么
    		Box box = new Box();
    		//先正确配置,就是开机按钮对开机命令,重启按钮对重启命令
    		box.setOpenCommand(openCommand);
    		box.setResetCommand(resetCommand);
    		
    		//3:然后模拟按下机箱上的按钮
    		System.out.println("正确配置下------------------------->");
    		System.out.println(">>>按下开机按钮:>>>");
    		box.openButtonPressed();
    		System.out.println(">>>按下重启按钮:>>>");
    		box.resetButtonPressed();
    		
    		//然后来错误配置一回,反正是进行参数化配置
    		//就是开机按钮对重启命令,重启按钮对开机命令
    		box.setOpenCommand(resetCommand);
    		box.setResetCommand(openCommand);
    		//4:然后还是来模拟按下机箱上的按钮
    		System.out.println("错误配置下------------------------->");
    		System.out.println(">>>按下开机按钮:>>>");
    		box.openButtonPressed();
    		System.out.println(">>>按下重启按钮:>>>");
    		box.resetButtonPressed();
    	}
    }

    7.可撤销的操作(重点)

    可撤销操作的意思就是:放弃该操作,回到未执行该操作的状态。
    有两种基本思路:
    1.补尝试,又称反操作式。
    打开关闭   加减
    2.存储恢复式
    把操作前得状态记录下来。

    8.补尝试,又称反操作式(以计算器为例)

    8.1操作运算接口(相当于主板接口)

    package demo12.command.example4;
    /**
     * 操作运算的接口
     */
    public interface OperationApi {
    	/**
    	 * 获取计算完成后的结果
    	 * @return 计算完成后的结果
    	 */
    	public int getResult();
    	/**
    	 * 设置计算开始的初始值
    	 * @param result 计算开始的初始值
    	 */
    	public void setResult(int result);
    	/**
    	 * 执行加法
    	 * @param num 需要加的数
    	 */
    	public void add(int num);
    	/**
    	 * 执行减法
    	 * @param num 需要减的数
    	 */
    	public void substract(int num);
    }

    8.2操作运算真实实现类(相当于主板)

    package demo12.command.example4;
    /**
     * 运算类,真正实现加减法运算
     */
    public class Operation implements OperationApi{
    	/**
    	 * 记录运算的结果
    	 */
    	private int result;
    	public int getResult() {
    		return result;
    	}
    	public void setResult(int result) {
    		this.result = result;
    	}
    	
    	public void add(int num){
    		//实现加法功能
    		result += num;
    	}
    	public void substract(int num){
    		//实现减法功能
    		result -= num;
    	}
    }

    8.3抽象命令接口

    package demo12.command.example4;
    /**
     * 命令接口,声明执行的操作,支持可撤销操作
     */
    public interface Command {
    	/**
    	 * 执行命令对应的操作
    	 */
    	public void execute();
    	/**
    	 * 执行撤销命令对应的操作
    	 */
    	public void undo();
    }

    8.4真实实现命令类(加命令和减命令)

    package demo12.command.example4;
    /**
     * 具体的加法命令实现对象
     */
    public class AddCommand implements Command{
    	/**
    	 * 持有具体执行计算的对象
    	 */
    	private OperationApi operation = null;
    	/**
    	 * 操作的数据,也就是要加上的数据
    	 */
    	private int opeNum;
    	/**
    	 * 构造方法,传入具体执行计算的对象
    	 * @param operation 具体执行计算的对象
    	 * @param opeNum 要加上的数据
    	 */
    	public AddCommand(OperationApi operation,int opeNum){
    		this.operation = operation;
    		this.opeNum = opeNum;
    	}
    	
    	public void execute() {
    		//转调接收者去真正执行功能,这个命令是做加法
    		this.operation.add(opeNum);
    	}
    	
    	public void undo() {
    		//转调接收者去真正执行功能
    		//命令本身是做加法,那么撤销的时候就是做减法了
    		this.operation.substract(opeNum);
    	}
    }
    
    
    package demo12.command.example4;
    /**
     * 具体的减法命令实现对象
     */
    public class SubstractCommand implements Command{
    	/**
    	 * 持有具体执行计算的对象
    	 */
    	private OperationApi operation = null;
    	/**
    	 * 操作的数据,也就是要减去的数据
    	 */
    	private int opeNum;
    	/**
    	 * 构造方法,传入具体执行计算的对象
    	 * @param operation 具体执行计算的对象
    	 * @param opeNum 要减去的数据
    	 */
    	public SubstractCommand(OperationApi operation,int opeNum){
    		this.operation = operation;
    		this.opeNum = opeNum;
    	}	
    	
    	public void execute() {
    		//转调接收者去真正执行功能,这个命令是做减法
    		this.operation.substract(opeNum);
    	}
    	
    	public void undo() {
    		//转调接收者去真正执行功能
    		//命令本身是做减法,那么撤销的时候就是做加法了
    		this.operation.add(opeNum);
    	}
    }

    8.5计算器类(相当于机箱)

    package demo12.command.example4;
    import java.util.*;
    /**
     * 计算器类,计算器上有加法按钮、减法按钮,还有撤销和恢复的按钮
     */
    public class Calculator {
    	/**
    	 * 命令的操作的历史记录,在撤销时候用
    	 */
    	private List<Command> undoCmds = new ArrayList<Command>();
    	/**
    	 * 命令被撤销的历史记录,在恢复时候用
    	 */
    	private List<Command> redoCmds = new ArrayList<Command>();
    	
    	private Command addCmd = null;
    	private Command substractCmd = null;
    	public void setAddCmd(Command addCmd) {
    		this.addCmd = addCmd;
    	}
    	public void setSubstractCmd(Command substractCmd) {
    		this.substractCmd = substractCmd;
    	}	
    	public void addPressed(){
    		this.addCmd.execute();
    		//把操作记录到历史记录里面
    		undoCmds.add(this.addCmd);
    	}
    	public void substractPressed(){
    		this.substractCmd.execute();
    		//把操作记录到历史记录里面
    		undoCmds.add(this.substractCmd);
    	}
    	public void undoPressed(){
    		if(this.undoCmds.size()>0){
    			//取出最后一个命令来撤销
    			Command cmd = this.undoCmds.get(this.undoCmds.size()-1);
    			cmd.undo();
    			//如果还有恢复的功能,那就把这个命令记录到恢复的历史记录里面
    			this.redoCmds.add(cmd );
    			//然后把最后一个命令删除掉,
    			this.undoCmds.remove(cmd);
    		}else{
    			System.out.println("很抱歉,没有可撤销的命令");
    		}
    	}
    	public void redoPressed(){
    		if(this.redoCmds.size()>0){
    			//取出最后一个命令来重做
    			Command cmd = this.redoCmds.get(this.redoCmds.size()-1);
    			cmd.execute();		
    			//把这个命令记录到可撤销的历史记录里面
    			this.undoCmds.add(cmd);
    			//然后把最后一个命令删除掉
    			this.redoCmds.remove(cmd);
    		}else{
    			System.out.println("很抱歉,没有可恢复的命令");
    		}
    	}
    }

    8.6客户端使用

    package demo12.command.example4;
    
    
    public class Client {
    	public static void main(String[] args) {
    		//1:组装命令和接收者
    		//创建接收者
    		OperationApi operation = new Operation();
    		//创建命令对象,并组装命令和接收者
    		AddCommand addCmd = new AddCommand(operation,5);
    		SubstractCommand substractCmd = new SubstractCommand(operation,3);
    		
    		//2:把命令设置到持有者,就是计算器里面
    		Calculator calculator = new Calculator();
    		calculator.setAddCmd(addCmd);
    		calculator.setSubstractCmd(substractCmd);
    		
    		//3:模拟按下按钮,测试一下
    		calculator.addPressed();
    		System.out.println("一次加法运算后的结果为:"+operation.getResult());
    		calculator.substractPressed();
    		System.out.println("一次减法运算后的结果为:"+operation.getResult());
    		
    		//测试撤消
    		calculator.undoPressed();
    		System.out.println("撤销一次后的结果为:"+operation.getResult());
    		calculator.undoPressed();
    		System.out.println("再撤销一次后的结果为:"+operation.getResult());
    		
    		//测试恢复
    		calculator.redoPressed();
    		System.out.println("恢复操作一次后的结果为:"+operation.getResult());
    		calculator.redoPressed();
    		System.out.println("再恢复操作一次后的结果为:"+operation.getResult());
    	}
    }

    9.存储恢复式

    先说几个概念:
    宏命令:多个命令的集合的命令
    队列请求:就是对命令对象进行排队,组成工作队列,然后依次取出命令对象来执行。
    存储恢复式的要点就在于将请求队列日志化,具体的案例我没有理解的很清楚, 以后遇到合适的例子再重新补充。

    10.思考命令模式

    10.1命令模式本质:

    封装请求

    10.2什么时候选用

    需要抽象出需要执行的动作,并参数化这些对象
    需要在不同时刻指定排列和执行请求
    需要支持取消操作
    当支持系统崩溃时,能将系统的操作功能重新执行一遍

    转载于:https://www.cnblogs.com/dyllove98/p/3221787.html

    展开全文
  • 文章目录重置密码硬盘引导阶段mbr主引导记录丢失如何恢复文件引导阶段内核引导阶段内核文件vmlinuz-【版本号】.x86_64 丢失初始化镜像文件initramfs-【版本号】.x86_64.img 丢失开机启动项被篡改 重置密码 模拟问题...

    重置密码

    模拟问题:假装忘记密码,或让别人改成不知道的密码
    解决思路:修改passwd文件

    1. 开机按上下键停止读秒
    2. 按E键进入编辑模式
    3. 选择内核启动行
    linux16 /vmlinuz-XXXXXX rw rd.break
    
    1. 启动系统ctrl+x
    2. 启动shell
    chroot /sysroot
    
    1. 修改密码
    echo 密码 |passwd --stdin root
    
    1. 建立SELinux重新初始化识别表
    touch /.autorelabel
    
    1. 退出重启系统
      2次exit

    硬盘引导阶段

    mbr主引导记录丢失如何恢复

    模拟问题:覆盖主引导记录dd if=/dev/zero of=/dev/vda bs=446 count=1
    解决思路:修改主引导记录,命令gurb2-install

    1. 真机插入系统安装光盘,虚拟机加载光盘系统
    2. 光盘启动,进入【Troubleshoting】模式
    3. 进入【Troubleshoting】模式,选择第二项【Rescue a Red Hat Enterprise system】
    4. 进入后选择1)Countinue
    5. 进行配置
    chroot /mnt/sysimage
    df
    #查看分区
    gurb2-install /dev/vda
    #grub2-install 启动分区所在硬盘
    

    文件引导阶段

    模拟问题:删除引导文件,引导文件/boot/grub2/grub.cfg
    解决思路:重新生成文件,使用命令gurb2-mkconfig

    1. 引导文件丢失,但是没有重启机器的情况:
    grub2-mkconfig > /boot/grub2/grub.cfg
    #重新生成引导文件
    
    1. 引导文件丢失,系统被重新启动的情况:
    #启动系统后进入的界面,进行操作:
    grub>set root='hd0,msdos1'
    #hd0第一块硬盘,msdos1第一块扇区
    grub>linux16 /boot/vmlinuz-3.10.0-514.el7.x86_64 ro root=/dev/vda1
    #找出指定文件,系统版本会不一样,文件名称最好用tab补齐
    #分区请按照系统安装情况进行选择
    grub>initrd16 /boot/initramfs-3.10.0-514.el7.x86_64.img
    #tab补齐文件名
    grub>boot
    
    #进入系统后
    grub2-mkconfig > /boot/grub2/grub.cfg
    #重新生成引导文件
    

    内核引导阶段

    内核文件vmlinuz-【版本号】.x86_64 丢失

    模拟问题:删除内核文件,文件路径/boot/vmlinuz-[版本号].x86_64
    解决思路:需要从光盘镜像中Packages中找出kernel-[版本号].x86_64.rpm,并从其中复制出vmlinuz-[版本号].x86_64文件

    1. 真机插入系统安装光盘,虚拟机加载光盘系统
    2. 光盘启动,进入【Troubleshoting】模式
    3. 进入【Troubleshoting】模式,选择第二项【Rescue a Red Hat Enterprise system】
    4. 进入后选择【1)Countinue】
    5. 进行配置
    chroot /mnt/sysimage/
    mount /dev/sr0 /meida
    cd /meida/Packages
    cp kernel-[版本号].x86_64.rpm /mnt/
    cd /mnt/
    rpm2cpio kernel-[版本号].x86_64.rpm | cpio -id
    cd boot/
    cp vmlinuz-[版本号].x86_64 /boot/
    
    1. 退出重启系统
      2次exit

    初始化镜像文件initramfs-【版本号】.x86_64.img 丢失

    模拟问题:删除初始化镜像文件,文件路径/boot/vmlinuz-[版本号].x86_64
    解决思路:重新生成文件,命令mkinitrd

    mkinitrd /boot/initramfs-$(uname -r).img $(uname -r)
    #使用命令生成,$(uname -r),查询出本系统内核版本直接使用
    
    1. 真机插入系统安装光盘,虚拟机加载光盘系统
    2. 光盘启动,进入【Troubleshoting】模式
    3. 进入【Troubleshoting】模式,选择第二项【Rescue a Red Hat Enterprise system】
    4. 进入后选择1)Countinue
    5. 进行配置
    chroot /mnt/sysimage/
    mkinitrd /boot/initramfs-$(uname -r).img $(uname -r)
    #制作初始化镜像文件
    

    开机启动项被篡改

    模拟问题:修改开机启动项为systemctl set-default poweroff.target或着修改/etc/systemd/system/defautl.target指向的启动项
    解决思路:进入系统重置开机启项

    defautl.target为一个链接文件,链接到了设定的target级别

    1. 开机按上下键停止读秒
    2. 按E键进入编辑模式
    3. 选择内核启动行
    linux16 /vmlinuz-XXXXXX ... 最后面写入 3 或 5
    #3 为init 3 字符界面;5 为init 5 图形界面
    
    1. 启动系统ctrl+x
    2. 系统启动后
    systemctl set-default graphical.target
    #将系统修改为图形开机
    ll /etc/systemd/system/defautl.target
    #查看修改是否正确
    
    展开全文
  • 进程管理

    2020-05-29 23:54:21
    init进程,读取各种各样的系统文件,初始化OS的启动,OS进入多用户状态,支持多用户登录。 原始的父进程 托管孤儿进程 (3)PID=2 页精灵进程,专门负责虚拟内存的请页操作。 函数: getpid --获取进程ID getppid ...
  • linux内核 0.11版本源码 带中文注释

    热门讨论 2009-08-31 15:10:21
    // 硬盘初始化程序(kernel/blk_drv/hd.c, 343 行) extern void floppy_init (void); // 软驱初始化程序(kernel/blk_drv/floppy.c, 457 行) extern void mem_init (long start, long end); // 内存管理初始化...
  • 3.不要对DOS过度狂热(有志于研究操作系统历史的朋友除外):DOS是一个工具,我们只是用它来辅助Win做一些Win下做不到的事情,如:初始化硬盘、修复系统等.所以当在Win下点几次鼠标就可以搞定的事情,根本没必要大费周折在...
  • INI:初始化文件;Mwave DSP Synth的“nwsynth.ini” GMS安装;Cravis Ultrasound bank安装 INP:Oracle 3.0版或早期版本的表单源代码 INRS:INRS远程通信声频 INS:InstallShield安装脚本;X-Internet签字文件;...
  • 复性任务、如何让程序做出选择、处理数据的多种方式以及如何使用函数等内容。另外,还讲述了C++在C 语言的基础上新增的许多特性,其中包括: ● 类和对象。 ● 继承。 ● 多态、虚函数和RTTI(运行阶段类型识别)...
  • 复性任务、如何让程序做出选择、处理数据的多种方式以及如何使用函数等内容。另外,还讲述了C++在C 语言的基础上新增的许多特性,其中包括: ● 类和对象。 ● 继承。 ● 多态、虚函数和RTTI(运行阶段类型识别)...
  • 复性任务、如何让程序做出选择、处理数据的多种方式以及如何使用函数等内容。另外,还讲述了C++在C 语言的基础上新增的许多特性,其中包括: ● 类和对象。 ● 继承。 ● 多态、虚函数和RTTI(运行阶段类型识别)...
  • 如果使用的电源功率偏小或没有连接辅助电源接口时,就会出现主机虽然能够加电,但因为提供给CPU的供电电流不足,造成CPU不能完成初始化而表现为主机没有自举启动过程。 12.硬盘,光驱,软驱性能部分损坏,造成电源...
  • 本书在向个人电脑用户,系统而详细地讲解了电脑的常见故障,同时读者更直接、更深刻地了解电脑故障产生原因和排除方法,从而达到能够自己解决电脑故障的目的。 本书分10章,共有1000多个实例,编写时从产生电脑...
  • A:可以,您可以其他朋友访问您的论坛进行一些测试。 首先,要确认您的计算机直接与 Internet 相连; 把这个地址告诉您的朋友:http://您计算机的IP地址(比如http://21.56.34.96) 七、程序更新 ==========...
  • A:可以,您可以其他朋友访问您的论坛进行一些测试。 首先,要确认您的计算机直接与 Internet 相连; 把这个地址告诉您的朋友:http://您计算机的IP地址(比如http://21.56.34.96) 七、程序更新 ==========...
  • malloc 初始化代码,它将找到当前中断点并初始化我们的变量: 清单 2. 分配程序初始化函数 /* Include the sbrk function */ #include void malloc_init() { /* grab the last valid address from the OS *...
  • 操作系统(内存管理)

    热门讨论 2009-09-20 12:55:25
    这里是我们的 malloc 初始化代码,它将找到当前中断点并初始化我们的变量: 清单 2. 分配程序初始化函数 /* Include the sbrk function */ #include void malloc_init() { /* grab the last valid address ...
  • Visual C++ 2008入门经典--详细书签版

    热门讨论 2013-02-02 16:07:15
    7.4.4 在构造函数中使用初始化列表 307 7.5 类的私有成员 308 7.5.1 访问私有类成员 310 7.5.2 类的友元函数 311 7.5.3 默认复制构造函数 313 7.6 this指针 315 7.7 类的const对象 317 7.7.1 类的const成员...
  • 7.4.4 在构造函数中使用初始化列表 307 7.5 类的私有成员 308 7.5.1 访问私有类成员 310 7.5.2 类的友元函数 311 7.5.3 默认复制构造函数 313 7.6 this指针 315 7.7 类的const对象 317 7.7.1 类的const成员...
  • Visual C++ 2005 入门经典 详细书签版

    热门讨论 2013-02-02 16:39:43
    7.4.4 在构造函数中使用初始化列表 320 7.5 类的私有成员 320 7.5.1 访问私有类成员 323 7.5.2 类的友元函数 324 7.5.3 默认复制构造函数 326 7.6 this指针 328 7.7 类的const对象 331 7.7.1 类的...
  • 7.4.4 在构造函数中使用初始化列表 320 7.5 类的私有成员 320 7.5.1 访问私有类成员 323 7.5.2 类的友元函数 324 7.5.3 默认复制构造函数 326 7.6 this指针 328 7.7 类的const对象 331 7.7.1 类的...
  • 本书不仅介绍操作系统的各要素,同时涉及开发操作系统需要的各个方面,比如如何建立开发环境、如何调试以及如何在虚拟机中运行等。书中的实例操作系统采用IA32作为默认平台,所以保护模式也作为必备知识储备收入书...
  • 本书不仅介绍操作系统的各要素,同时涉及开发操作系统需要的各个方面,比如如何建立开发环境、如何调试以及如何在虚拟机中运行等。书中的实例操作系统采用IA32作为默认平台,所以保护模式也作为必备知识储备收入书...
  • 知识点:增加打开时,Word文档初始显示比例为“最大的合适比例” 知识点:增加文件可以以独立的窗口打开,例Word文档在Word中打开 修正:新增知识点默认分类的可能出错,以“全部数据库”的方式显示时,缺省数据库...
  • 知识点:增加打开时,Word文档初始显示比例为“最大的合适比例” 知识点:增加文件可以以独立的窗口打开,例Word文档在Word中打开 修正:新增知识点默认分类的可能出错,以“全部数据库”的方式显示时,缺省数据库...
  • 知识点:增加打开时,Word文档初始显示比例为“最大的合适比例” 知识点:增加文件可以以独立的窗口打开,例Word文档在Word中打开 修正:新增知识点默认分类的可能出错,以“全部数据库”的方式显示时,缺省数据库...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    统一建模语言是一种通用的可视建模语言,用于对软件系统的制品进行规范、可视处理,然后构造它们并建立它们的文档。 UML的发展过程 图 与 语言 谁一级棒? UML的优势 过去数十种面向对象的建模语言各自为战...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    18.4 代 码 优 .252 18.5 小 结 .254 第五部分 附 录 .255 附录 A 关 键 字.255 附录 B 错 误 码.256 附录 C .Net 名字空间成员速查.269 参 考 资 料 .300 <<page 4>> page begin==================...
  • C#微软培训资料

    2014-01-22 14:10:17
    18.4 代 码 优 .252 18.5 小 结 .254 第五部分 附 录 .255 附录 A 关 键 字.255 附录 B 错 误 码.256 附录 C .Net 名字空间成员速查.269 参 考 资 料 .300 <<page 4>> page begin==================...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

如何让硬盘初始化