Arm 系统内存管理单元 (SMMU) 架构是用于 Arm 设备的标准且得到良好支持的 IOMMU，可同时实现隔离和直接分配。

长期以来，在运行客户机时，KVM 会在启用第 2 阶段转换的情况下运行；而在运行主机 Linux 内核时，KVM 会在停用第 2 阶段转换的情况下运行。此架构允许来自主机第 1 阶段 MMU 的内存访问通过第 2 阶段 MMU，从而允许从主机无限制地访问客户机内存页面。

可使用as将u8类型转char 之所以不支持其他整数类型，是因为其他整数类型的值可能无法转换为char(即不在UTF-8编码表范围的整数值)

可使用as将char转为各种整数类型，目标类型小于4字节时，将从高位截断

在存储char类型数据时，会将其转换为UTF-8编码的数据(即Unicode代码点)进行存储。

一个程序遵循Copyleft，我们首先声明它是有版权的；然后，我们给它加上发布条款，这个条款就是一个法律声明，它赋予所有人有使用、修改和重新发布程序的代码及其衍生作品的权利，但要求在这个过程中保持发布规则不变。

自由地分发该软件修改后的拷贝。

let a = b'A'; // a的类型自动推导为u8

// 需注意，下面的数值都加上了类型后缀。 // 这是因为在调用方法的时候，需要知道值的 // 所属类型才能找到这种类型具有的方法

在Rust中，可以在表达式结尾加上分号;来将表达式转换为【语句】。

用于声明或定义的代码都是语句。例如let声明变量、fn定义函数、struct声明结构体等。

let x = if true { println!("true"); 33 // 分支的最后一条代码计算结果赋值给x，不能分号结尾 } else { println!("false"); 44 // 分支的最后一条代码计算结果赋值给x，不能分号结尾 }; // 这个结尾分号表示let语句的结尾分号

Rust允许重复声明同名变量，后声明的变量将遮盖(shadow)前面已声明的变量。

<line id="1"> the <bold>First</bold>line</line>

标准IO函数（如fread，fwrite等）会在内存中建立缓冲，该函数刷新内存缓冲，将内容写入内核缓冲，要想将其真正写入磁盘，还需要调用fsync。（即先调用fflush然后再调用fsync，否则不会起作用）。fflush以指定的文件流描述符为参数（对应以fopen等函数打开的文件流），仅仅是把上层缓冲区中的数据刷新到内核缓冲区就返回，因此相对于fsync而言不是很安全，还需要再调用一下fsync来把数据真正写入硬盘。

printf with a "%zd" format expects an argument of the signed type that corresponds to the unsigned type size_t. Standard C doesn't provide a name for this type or a good way to determine what it is. If size_t is a typedef for unsigned long, for example, then "%zd" expects an argument of type long, but that's not a portable assumption.

SecurityContext描述系统资源的安全上下文，SELinux的安全访问策略就是在安全上下文的基础上实现的；

SecurityPolicy描述系统资源的安全访问策略，系统启动时init进程负责把策略文件加载到内核的LSM模块中；

neverallow { domain -kernel -init -recovery } block_device:blk_file { open read write };

安全上下文

2、正向和负向：

1、先行和后行：

单词边界

如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。

如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。

\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]

一般对静态变量的传递为拷贝，对动态变量的传递为引用。

实例变量指的是在任意类方法内部，以“self.变量名”的方式定义的变量，其特点是只作用于调用方法的对象。另外，实例变量只能通过对象名访问，无法通过类名访问。

2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import * __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName（ 对象名._类名__私有属性名 ）访问属性

实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。

局部变量：定义在方法中的变量，只作用于当前实例的类。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

类的帮助信息可以通过ClassName.__doc__查看。

try: 正常的操作 ...................... except ExceptionType, Argument: 你可以在这输出 Argument 的值...

try-finally 语句无论是否发生异常都将执行最后的代码。

如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。 如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。 两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

#!/usr/bin/python # -*- coding: UTF-8 -*- a = [1,2,3] b = a if len(a) != 0 else "" print(b) c=[] d = c if len(c) != 0 else "c 是一个空列表" print(d)

vars(obj) 返回一个object的name space。用dictionary表示

from modname import name1[, name2[, ... nameN]]

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。

li[i], li[-i - 1] = li[-i - 1], li[i]

一个生产者可能对应着多个消费者，生产者向队列中插入一条数据之后发出signal，然后各个消费者线程的pthread_cond_wait获取mutex后返回，当然，这里只有一个线程获取到了mutex，然后进行处理，其它线程会pending在这里，处理线程处理完毕之后释放mutex，刚才等待的线程中有一个获取mutex，如果这里用if，就会在当前队列为空的状态下继续往下处理，这显然是不合理的。

void enqueue_msg(struct msg *mp) { pthread_mutex_lock(&qlock); mp->m_next = workq; workq = mp; pthread_mutex_unlock(&qlock); pthread_cond_signal(&qready); }

void process_msg(void) { struct msg *mp; for (;;) { pthread_mutex_lock(&qlock); while (workq == NULL) pthread_cond_wait(&qready, &qlock); mp = workq; workq = mp->m_next; pthread_mutex_unlock(&qlock); /* now process the message mp */ } }

mmc rpmb read-block <rpmb device> <address> <blocks count> <output file> [key file]

mmc rpmb write-block <rpmb device> <address> <256 byte data file> <key file>

mmc rpmb read-counter <rpmb device>

mmc rpmb write-key <rpmb device> <key file>

A向B请求服务(比如说登录某个网站)，A将密码hash化传给B。但是在这中间，E抓取到该hash值。此后，E冒充A向B发送同样的hash值来获取服务。

Write protect was designed to protect against data corruption or erasure (whether malicious or unintentional). Once write protect is set, a host can’t erase or write to the specified protected area. However, unlike password lock, data can still be read from this area.

Password lock was the first security feature integrated into the eMMC spec; previously it had been implemented in legacy SD cards. The password lock feature is designed to protect the contents of the user area from any type of access (read, write, or erase).

不定长参数 * 输出一般都是元组的结构形式， ** 双星输出的都是字典形式的 结构，在传值的中也要确保值得准确匹配才行，不然会报错。

不带参数值的return语句返回None。

加了星号（*）的变量名会存放所有未命名的变量参数。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

在 python 中，类型属于对象，变量是没有类型的： a=[1,2,3] a="Runoob" 以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

if (!decryptWithKeymasterKey(keymaster, dir, keyParams, authToken, encryptedMessage, key, keepOld))

if (!encryptWithKeymasterKey(keymaster, dir, keyParams, authToken, key, &encryptedKey, false))

if (!generateKeymasterKey(keymaster, auth, appId, &kmKey)) return false; if (!writeStringToFile(kmKey, dir + "/" + kFn_keymaster_key_blob)) return false;

if (!auth.usesKeymaster()) { return kStretch_none; } else if (auth.secret.empty()) { return kStretch_nopassword; }

if (!writeStringToFile(encryptedKey, dir + "/" + kFn_encrypted_key)) return false;

if (!generateAppId(auth, stretching, salt, secdiscardable_hash, &appId)) return false;

if (stretchingNeedsSalt(stretching)) { if (ReadRandomBytes(SALT_BYTES, salt) != OK) { LOG(ERROR) << "Random read failed"; return false; } if (!writeStringToFile(salt, dir + "/" + kFn_salt)) return false; }

if (!writeStringToFile(stretching, dir + "/" + kFn_stretching)) return false;

if (!createSecdiscardable(dir + "/" + kFn_secdiscardable, &secdiscardable_hash)) return false;

if (!writeStringToFile(kCurrentVersion, dir + "/" + kFn_version)) return false;

auto nonceBlob = outParams.GetTagValue(km::TAG_NONCE);

static constexpr size_t SALT_BYTES = 1 << 4;

if (!readFileToString(dir + "/" + kFn_encrypted_key, &encryptedMessage)) return false;

if (!readFileToString(dir + "/" + kFn_salt, &salt)) return false;

if (!readFileToString(dir + "/" + kFn_stretching, &stretching)) return false;

if (!readSecdiscardable(dir + "/" + kFn_secdiscardable, &secdiscardable_hash)) return false;

if (!readFileToString(dir + "/" + kFn_version, &version)) return false;

if (!readRandomBytesOrLog(SECDISCARDABLE_BYTES, &secdiscardable)) return false;

static constexpr size_t SECDISCARDABLE_BYTES = 1 << 14;

锁卡的目的：一些运营商会要求控制某一类卡的使用，从而保护自己的利益（运营商定制机）

static std::string generateKeyRef(const uint8_t* key, int length)

return std::string((char*)key_ref2, FS_KEY_DESCRIPTOR_SIZE);

SHA512_Init(&c); SHA512_Update(&c, key_ref1, SHA512_DIGEST_LENGTH); unsigned char key_ref2[SHA512_DIGEST_LENGTH]; SHA512_Final(key_ref2, &c);

SHA512_Init(&c); SHA512_Update(&c, key, length); unsigned char key_ref1[SHA512_DIGEST_LENGTH]; SHA512_Final(key_ref1, &c);

LOG(DEBUG) << "Added key " << key_id << " (" << ref << ") to keyring " << device_keyring << " in process " << getpid();

// Map user ids to key references std::map<userid_t, std::string> s_de_key_raw_refs; std::map<userid_t, std::string> s_ce_key_raw_refs; // TODO abolish this map, per b/26948053 std::map<userid_t, KeyBuffer> s_ce_keys;

// DE_n key auto system_de_path = android::vold::BuildDataSystemDePath(user_id); auto misc_de_path = android::vold::BuildDataMiscDePath(user_id); auto vendor_de_path = android::vold::BuildDataVendorDePath(user_id); auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);

// DE_sys key auto system_legacy_path = android::vold::BuildDataSystemLegacyPath(user_id); auto misc_legacy_path = android::vold::BuildDataMiscLegacyPath(user_id); auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);

static std::vector<std::string> get_ce_key_paths(const std::string& directory_path)

if (entry->d_type != DT_DIR || entry->d_name[0] != 'c') { LOG(DEBUG) << "Skipping non-key " << entry->d_name; continue; }

if (entry->d_type != DT_DIR || !is_numeric(entry->d_name)) { LOG(DEBUG) << "Skipping non-de-key " << entry->d_name; continue; }

// Represents the information needed to decrypt a disk encryption key. // If "token" is nonempty, it is passed in as a required Gatekeeper auth token. // If "token" and "secret" are nonempty, "secret" is appended to the application-specific // binary needed to unlock. // If only "secret" is nonempty, it is used to decrypt in a non-Keymaster process. class KeyAuthentication { public: KeyAuthentication(const std::string& t, const std::string& s) : token{t}, secret{s} {}; bool usesKeymaster() const { return !token.empty() || secret.empty(); }; const std::string token; const std::string secret; };

Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：

const std::string device_key_dir = std::string() + DATA_MNT_POINT + fscrypt_unencrypted_folder; const std::string device_key_path = device_key_dir + "/key"; const std::string device_key_temp = device_key_dir + "/temp";

// Parse the arguments: exec [SECLABEL [UID [GID]*] --] COMMAND ARGS... // SECLABEL can be a - to denote default std::size_t command_arg = 1; for (std::size_t i = 1; i < args.size(); ++i) { if (args[i] == "--") { command_arg = i + 1; break; } }

std::size_t nr_supp_gids = command_arg - 1 /* -- */ - 4 /* exec SECLABEL UID GID */;

std::vector<std::string> str_args(args.begin() + command_arg, args.end());

三、锁卡流程解析 　　1.首先modem侧检测SIM卡的配置信息并与之作比对，若匹配则继续加载SIM卡，若不匹配，则上报加锁信息 　　2.RIL层检测到modem上报的加锁信息，然后发送给framework层，最终在AP层监测到事件： 　　3.AP层显示出锁卡界面，要求用户输入解锁码进行解锁

锁卡即SIMLock,当手机开机启动或者插入SIM卡时，手机modem侧预置在NV项中的配置信息会与SIM卡中的信息做比对，检测是否匹配。若匹配，则SIM卡可以正常使用。若不匹配，则SIM卡相关功能均无法正常使用，例如拨打电话、发送短信及上网等；或者是只能注册2G网，不能注册4G。

SIMLock锁和图案锁，数字密码锁，PIN码锁，PUK锁一样，是Keyguard模块中的一种锁。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

tup3 = "a", "b", "c", "d"

>>> a=(1,2,3,4,5,6) >>> c=a[1:4]+a[5] # 报错, a[5] 被当成了整型 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate tuple (not "int") to tuple

list_2d = [ [0 for i in range(5)] for i in range(5)]

list_2d = [[0 for col in range(cols)] for row in range(rows)]

std::string name = "exec " + std::to_string(exec_count) + " (" + Join(str_args, " ") + ")";