深入理解Android之设备加密Device Encryption

#通过import引入其他rc文件。在flo设备中，$ro.hardware的值就是“flo”

#在init的组织结构中，import对应的是一个section。一个section从对应关键词开始，直到

#下一个section的关键词为止

import /init.environ.rc

import /init.usb.rc

import /init.${ro.hardware}.rc

import /init.${ro.zygote}.rc

import /init.trace.rc

#on xxx这种结构中，on所对应的也是一个section，early-init是这个section的名字

#一个section内可以包含很多command。比如下面的write，就属于command

on early-init

    write/proc/1/oom_score_adj -1000

......

on xxx #early-initsection到xxx前结束

#除了import，on之外，service关键词也代表一个section，如下面的：

#和on section不一样的是，servicesection后面的语句描述的

#除了command外，还有这个section的属性（option）。属性也有一些关键词，比如

#下面的class，critical。

service ueventd /sbin/ueventd

    classcore #描述该service属于core这种class

    critical  #描述该service属于critical级别

    seclabelu:r:ueventd:s0 #seclabel是一种command

.......

注意：关于init的代码分析我们就不在啰嗦。感兴趣的兄弟们请研究卷1。

on fs

    mount_all ./fstab.flo

    restorecon_recursive/persist

    setpropro.crypto.fuse_sdcard true

    write/sys/kernel/boot_adsp/boot 1

int do_mount_all(int nargs, char **args)

{

    pid_tpid;  int ret = -1; int child_ret = -1;

    intstatus;  const char *prop; struct fstab*fstab;

    //init会fork一个子进程用来执行mount

    pid =fork();

    if (pid> 0) {

        //init等子进程的执行结果

        intwp_ret = TEMP_FAILURE_RETRY(waitpid(pid,&status, 0));

       ......

        if(WIFEXITED(status)) {

           ret = WEXITSTATUS(status);

        }.....

    } elseif (pid == 0) {

        //子进程，args[1]参数就是”/fstab.flo”,fs_mgr_read_fstab将解析fstab文件

       fstab = fs_mgr_read_fstab(args[1]);

        //fs_mgr_mount_all的返回值具有决定意义

       child_ret = fs_mgr_mount_all(fstab);

       fs_mgr_free_fstab(fstab);

       _exit(child_ret);

    }

    //回到init进程，子进程的返回结果非常重要：

    if (ret== FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {

        //如果fstab里设置了默认加密，则设置下面这个属性

       property_set("vold.decrypt","trigger_encryption");

    } elseif (ret == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED) {

        //如果设备已经加密，则我们需要做一些处理：

       property_set("ro.crypto.state","encrypted");

        property_set("vold.decrypt", "trigger_default_encryption");

    } elseif (ret == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED){

       //如果设备没有加密，则不需要做什么处理，和以前一样

       property_set("ro.crypto.state","unencrypted");

       action_for_each_trigger("nonencrypted", action_add_queue_tail);

    } elseif (ret == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {

       //....其他

        ret= wipe_data_via_recovery();

    }

    returnret;

}

int fs_mgr_mount_all(struct fstab *fstab)

{

    int i =0; int encryptable = FS_MGR_MNTALL_DEV_NOT_ENCRYPTED;

    interror_count = 0; int mret = -1;

    intmount_errno = 0;  int attempted_idx = -1;

    ......

    for (i =0; i < fstab->num_entries; i++) {

       ......

        intlast_idx_inspected;

        //mount fstab里的项,返回值很重要

        mret= mount_with_alternatives(fstab, i,&last_idx_inspected,

                   &attempted_idx);

        i =last_idx_inspected;

       mount_errno = errno;

        //mret=0，表示mount成功。如果设备已经加密，则mount是不会成功的。

       //所以，这里需要考虑第一次开机，然后发现设备被强制要求加密的情况

        if(!mret) {

          //如果该项是强制需要加密的（图2中的encryptable换成forceencrypt）

           if (  (fstab->recs[attempted_idx].fs_mgr_flags & MF_FORCECRYPT)

               //或者设置了“ro.vold.forceencryption”属性

               || (device_is_force_encrypted()

                   && fs_mgr_is_encryptable(&fstab->recs[attempted_idx]))) {

               //先卸载这个需要强制加密的设备

               if (umount(fstab->recs[attempted_idx].mount_point)== 0) {

                   if (encryptable == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) {

                        encryptable= FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION;

                   } else {

                       //系统只支持对一个存储分区加密，不能对多个设备加密

                        encryptable =FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED;

                   }

               } ......

           }

          continue;

        }

    //如果mount失败，则需要判断是不是已经加密过的设备。这种情况下，不能通过mount挂载！

    if (mret&& mount_errno != EBUSY && mount_errno != EACCES &&

      fs_mgr_is_encryptable(&fstab->recs[attempted_idx])) {

        //加密的设备，但是前4K的内容要么是0要么是0xff。这是被wiped分区，需要recovery

       if(partition_wiped(fstab->recs[attempted_idx].blk_device)) {

          ......

          encryptable = FS_MGR_MNTALL_DEV_NEEDS_RECOVERY;

          continue;

       }else {

         //在/data目录下挂载tmpfs设备，而不是指定的实际设备

         if(fs_mgr_do_tmpfs_mount(fstab->recs[attempted_idx].mount_point)

                  < 0) {......

          }

       }

        encryptable = FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED;

        }  ......

    }

     .......

}

注意：为什么要挂载tmpfs到/data/目录下呢？这是因为没有这个/data目录，系统根本没办法起来。因为系统很多运行时保存的信息，app自己的缓存目录等都放在/data下。为了保证系统能启动，所以这里先弄一个临时/data目录。等到后续把加密设备通过device-mapper方式准备好后，我们再把加密设备挂载到/data/目录下。注意，加密设备的mount不是直接挂载加密设备，而是通过挂载一个device-mapper来实现的。

#当属性vold.decrypt的值变成trigger_enryption后，将执行两个动作：

on property:vold.decrypt=trigger_encryption

    startsurfaceflinger  #第一个动作是启动surfaceflinger服务

    startencrypt  #第二个动作是启动encrypt动作

....

#encrypt section定义，它对应为执行/system/bin/vdc函数

service encrypt /system/bin/vdc --wait cryptfsenablecrypto inplace default

    disabled

    oneshot

    # voldwill set vold.decrypt to trigger_restart_framework (default

    #encryption)

int main(int argc, char **argv) {

    intsock; int wait_for_socket; char *progname;

    progname= argv[0];

    //关于vold的故事，可阅读我的《深入理解Android》卷1，里边有详细的源码分析。

   //vdc将通过“vold”这个socket和vold通信。

    while((sock = socket_local_client("vold",

                                ANDROID_SOCKET_NAMESPACE_RESERVED,

                                SOCK_STREAM))< 0) {

         ......

    }

    if(!strcmp(argv[1], "monitor")) {

       exit(do_monitor(sock, 0));

    } else {

       exit(do_cmd(sock, argc, argv));

    }

}

static int do_cmd(int sock, int argc, char **argv){

    charfinal_cmd[255] = "0 "; int i;size_t ret;

    for (i =1; i < argc; i++) {

        char*cmp;

       .....

    //把命令发给vold，vdc工作就算完成了

    write(sock, final_cmd,strlen(final_cmd) + 1) < 0;

       .....

    returndo_monitor(sock, 1);

}

on property:vold.decrypt=trigger_default_encryption

    start defaultcrypto

...

#也是启动vdc来挂载已加密设备

service defaultcrypto /system/bin/vdc --wait cryptfs mountdefaultencrypted

    disabled

    oneshot

    # voldwill set vold.decrypt to trigger_restart_framework (default

    #encryption) or trigger_restart_min_framework (other encryption)

public View onCreateView(LayoutInflater inflater,ViewGroup container,

                     Bundle savedState) {

 mContentView = inflater.inflate(R.layout.crypt_keeper_settings, null);

 mIntentFilter = new IntentFilter();

 mIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);

 mInitiateButton = (Button) mContentView.findViewById(R.id.initiate_encrypt);

 mInitiateButton.setOnClickListener(mInitiateListener);

 mInitiateButton.setEnabled(false);

  ......

  returnmContentView;

  }

private Button.OnClickListener mInitiateListener =new Button.OnClickListener() {

   @Override

    publicvoid onClick(View v) {

    if (!runKeyguardConfirmation(KEYGUARD_REQUEST)){

       ......

    }

   }

 };

//直接看代码：

private boolean runKeyguardConfirmation(intrequest) {

   Resources res = getActivity().getResources();

   ChooseLockSettingsHelper helper =

                       newChooseLockSettingsHelper(getActivity(), this);

    //从DevicePolicyManager那获取设备的密码控制要求，如果没有指定的话，将直接进入

   //跳入后面的流程

    if(helper.utils().getKeyguardStoredPasswordQuality()

                 ==DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED) {

         //一般是没有设置密码控制级别的，所以加密的时候将使用默认加密，密码为””

         showFinalConfirmation(StorageManager.CRYPT_TYPE_DEFAULT, "");

         return true;

    }

    returnhelper.launchConfirmationActivity(request, null,

   res.getText(R.string.crypt_keeper_confirm_encrypt),

    true);

}

private void showFinalConfirmation(int type,String password) {

   Preference preference = new Preference(getActivity());

    //启动CrypteKeeperConfirm界面

   preference.setFragment(CryptKeeperConfirm.class.getName());

   preference.setTitle(R.string.crypt_keeper_confirm_title);

    //type为默认的加密方法，password为””

   preference.getExtras().putInt("type", type);

   preference.getExtras().putString("password", password);

   ((SettingsActivity) getActivity()).onPreferenceStartFragment(null,

         preference);

}

private Button.OnClickListener mFinalClickListener= new

                Button.OnClickListener() {

   publicvoid onClick(View v) {

        .....

        //启动一个Blank Activity，代码也在此文件中

       Intent intent = new Intent(getActivity(), Blank.class);

       intent.putExtras(getArguments());

       startActivity(intent);

        //2. The system locale.

        try{

        //调用MountService的setField功能，设置系统语言

       IBinder service = ServiceManager.getService("mount");

       IMountService mountService = IMountService.Stub.asInterface(service);

       mountService.setField("SystemLocale",

                    Locale.getDefault().toLanguageTag());

        }......

    }

 };

public static class Blank extends Activity {

    privateHandler mHandler = new Handler();

   publicvoid onCreate(Bundle savedInstanceState) {

      super.onCreate(savedInstanceState);

      setContentView(R.layout.crypt_keeper_blank);

       .....

       //禁止使用状态栏的功能，加密过程最好是不要被打搅！

       StatusBarManager sbm = (StatusBarManager)

                        getSystemService(Context.STATUS_BAR_SERVICE);

        sbm.disable(StatusBarManager.DISABLE_EXPAND

           | StatusBarManager.DISABLE_NOTIFICATION_ICONS

           | StatusBarManager.DISABLE_NOTIFICATION_ALERTS

           | StatusBarManager.DISABLE_SYSTEM_INFO

           | StatusBarManager.DISABLE_HOME

            | StatusBarManager.DISABLE_SEARCH

           | StatusBarManager.DISABLE_RECENT

           | StatusBarManager.DISABLE_BACK);

       mHandler.postDelayed(new Runnable() {

       public void run() {

           IBinder service = ServiceManager.getService("mount");

           IMountService mountService =

                    IMountService.Stub.asInterface(service);

           try {

               Bundle args = getIntent().getExtras();

              //调用MountService的encryptStorage函数

                mountService.encryptStorage(args.getInt("type", -1),

                      args.getString("password"));

           }.....

        }

        },700);

    }

    }

private void startBootstrapServices() {

   ......

  StringcryptState = SystemProperties.get("vold.decrypt");

    // ENCRYPTING_STATE值为“trigger_restart_min_framework”

    if(ENCRYPTING_STATE.equals(cryptState)) {

       mOnlyCore= true;

    } elseif (ENCRYPTED_STATE.equals(cryptState)) {

     // ENCRYPTED_STATE值为“1“

       mOnlyCore = true;

    }

   ......

}

注意：对于挂载加密设备来说，系统其实并不是真的去解密存储设备，然后再挂载。而仅是判断用户输入的密码是不是对的。如果是对的话，它会通过device-mapper去挂载一个虚拟设备到/data下，而这个虚拟设备一方面连着实际的block设备。这样，当用户从/data读取、写入数据时，这个虚拟设备都会把数据进行加解密。比如用户读数据时，它会从真实设备里读取加密后的数据，然后解密返回给用户。用户写数据时候，它会加密后再写到真实设备中！

注意，vold的源码，我曾经在《深入理解Android》卷1中讲过了。那时候还是2.3，但是即使到5.1为止，vold的代码和结构都没有太大的变动。

CommandListener::CommandListener() :

                FrameworkListener("vold", true) {

   registerCmd(new DumpCmd());

   registerCmd(new VolumeCmd());

   registerCmd(new AsecCmd());

   registerCmd(new ObbCmd());

   registerCmd(new StorageCmd());

   registerCmd(new CryptfsCmd());

   registerCmd(new FstrimCmd());

}

#wipe和inplace：wipe表示先清干净存储设备，然后加密，inplace表示对现有数据加密

#default等，表示密码模式。default是默认密码，password，或者pin，patter都和锁屏使用方式

#有关

cryptfsenablecrypto <wipe|inplace> default|password|pin|pattern [passwd]

int cryptfs_enable(char *howarg, int type, char *passwd, intallow_reboot)

{

    char*adjusted_passwd = adjust_passwd(passwd);

    if(adjusted_passwd) {

       passwd = adjusted_passwd;

    }

    int rc =cryptfs_enable_internal(howarg,type, passwd, allow_reboot);

   free(adjusted_passwd);

    returnrc;

}

int cryptfs_enable_default(char *howarg, int allow_reboot)

{

     //如果使用默认密码，就走这个流程：

    return cryptfs_enable_internal(howarg,CRYPT_TYPE_DEFAULT,

                          DEFAULT_PASSWORD, allow_reboot);

}

int cryptfs_enable_internal(char *howarg, intcrypt_type, char *passwd,

                            int allow_reboot)

{

    int how= 0;

    charcrypto_blkdev[MAXPATHLEN], real_blkdev[MAXPATHLEN];

    unsignedlong nr_sec;

    unsignedchar decrypted_master_key[KEY_LEN_BYTES];

    intrc=-1, fd, i, ret;

    structcrypt_mnt_ftr crypt_ftr;

    structcrypt_persist_data *pdata;

    charencrypted_state[PROPERTY_VALUE_MAX];

    charlockid[32] = { 0 };

    charkey_loc[PROPERTY_VALUE_MAX];

    charfuse_sdcard[PROPERTY_VALUE_MAX];

    char*sd_mnt_point;

    int num_vols;

    structvolume_info *vol_list = 0;

    off64_tpreviously_encrypted_upto = 0;

    if(!strcmp(howarg, "wipe")) {

      how =CRYPTO_ENABLE_WIPE;

    } elseif (! strcmp(howarg, "inplace")) {

      how = CRYPTO_ENABLE_INPLACE; //我们对应这种情况

    } ....

    /*

     不知道什么原因，上一次加密还没处理完，系统就重启或者vold就重启了。为了处理这种情况，

     vold会把加密过程都写到一个地方去，然后要每次加密前都需要检查。因为一旦加密被干扰而又没

     正确处理的话，用户数据就会丢失，这是非常严重的事故！

    */

    if (how== CRYPTO_ENABLE_INPLACE

         && get_crypt_ftr_and_key(&crypt_ftr)== 0

         && (crypt_ftr.flags & CRYPT_ENCRYPTION_IN_PROGRESS)) {

       previously_encrypted_upto = crypt_ftr.encrypted_upto;

       crypt_ftr.encrypted_upto = 0;

       crypt_ftr.flags &= ~CRYPT_ENCRYPTION_IN_PROGRESS;

       crypt_ftr.flags |= CRYPT_INCONSISTENT_STATE;

       put_crypt_ftr_and_key(&crypt_ftr);

    }

static int get_crypt_ftr_and_key(structcrypt_mnt_ftr *crypt_ftr)

{

  int fd;

  unsignedint nr_sec, cnt;

  off64_tstarting_off;

  int rc =-1;

  char*fname = NULL;

  structstat statbuf;

  /*

   get_crypt_ftr_info用于获取加密信息的存储位置。按Android的设计，这个信息可以存储在

   两个地方。一个是fstab里encryptable=xxxx中xxx这个存储设备里，也可以存储在

   需要挂载的设备里最后一段空间里。比如fstab.flo中，

   1 /dev/block/platform/msm_sdcc.1/by-name/userdata是要挂载的设备，所以加密信息

     存储在这个设备的最后一段空间里。但是由于我们还有下面这句话：

   2 encryptable=/dev/block/platform/msm_sdcc.1/by-name/metadata

     所以实际的加密信息存储在metadata文件里

  */

  get_crypt_ftr_info(&fname, &starting_off);

  //上面函数的fname指明加密信息存储在哪个文件中，starting_off表示信息存储在文件里哪个位置

  fd =open(fname, O_RDWR));

  fstat(fd,&statbuf);

  if(S_ISREG(statbuf.st_mode) && (statbuf.st_size != 0x4000))

     gotoerrout;

  if(lseek64(fd, starting_off, SEEK_SET) == -1)

     gotoerrout;

 //读取加密信息，保存在一个crypt_mnt_ftr这样的结构体里

 if ( (cnt =read(fd, crypt_ftr, sizeof(structcrypt_mnt_ftr)))

              != sizeof(struct crypt_mnt_ftr))

   gotoerrout;

  ......

  rc = 0;

  ......

}

 //取出"ro.crypto.state"的属性，本例中其值应该是空

 property_get("ro.crypto.state",encrypted_state, "");

 if(!strcmp(encrypted_state, "encrypted") &&!previously_encrypted_upto) {

     //previously_encrypted_upto表示上一次加密的进度，如果是0的话，而加密状态又是

    //”encrypted”，这就是有问题啊

        gotoerror_unencrypted;

   }

  //取出key存储的路径和待加密的路径，本例中：

  //key_loc=/dev/block/platform/msm_sdcc.1/by-name/metadata

  //real_blkdev=/dev/block/platform/msm_sdcc.1/by-name/userdata

 fs_mgr_get_crypt_info(fstab, key_loc, 0, sizeof(key_loc));

 fs_mgr_get_crypt_info(fstab, 0, real_blkdev, sizeof(real_blkdev));

    //打开真实设备并获取它的夸个数！

    fd =open(real_blkdev, O_RDONLY);

    nr_sec = get_blkdev_size(fd));

   close(fd);

   //KEY_IN_FOOTER：key是不是存储在存储空间的最后一部分。我们这不是

    if ((how== CRYPTO_ENABLE_INPLACE) && (!strcmp(key_loc, KEY_IN_FOOTER))) {

        ......

    }

    //加密耗电，所以要搞一个WakeLock

   snprintf(lockid, sizeof(lockid), "enablecrypto%d", (int)getpid());

   acquire_wake_lock(PARTIAL_WAKE_LOCK, lockid);

    ......//其他一些小处理

    //设置属性，init肯定会干一些事情！

   property_set("vold.decrypt","trigger_shutdown_framework");

   SLOGE("Just asked init to shut down class main\n");

     //卸载SDCard中ASEC相关的东西

     vold_unmountAllAsecs();

   property_get("ro.crypto.fuse_sdcard", fuse_sdcard,"");

   ......//SDCard的处理

   //卸载/data分区

   if(wait_and_unmount(DATA_MNT_POINT, false)) {

        ......

    }

on property:vold.decrypt=trigger_shutdown_framework

   class_reset late_start #reset late_start和main类别的服务

   class_reset main#如果查看init代码的话，reset就是干掉这些服务，并且不会自动重启它们

  if (how ==CRYPTO_ENABLE_INPLACE) {

      //挂载tmpfs到/data目录。注意，这里似乎和init的做法有重复。这是因为我们是直接在

      //settings里触发的。而Settings则是在加载加密设备的时候触发的。

      fs_mgr_do_tmpfs_mount(DATA_MNT_POINT);

      //设置加密进度，由“vold.encrypt_progress“属性值表示

      property_set("vold.encrypt_progress","0");

      //在data目录下创建一些必要的目录，否则framework将启动不了

      prep_data_fs();

      sleep(2);

    }

   //首次加密，所以previously_encrypted_upto为0

   if(previously_encrypted_upto == 0) {

        //初始化一个加密上下文信息，比如版本号之类的

        cryptfs_init_crypt_mnt_ftr(&crypt_ftr);

        //设置待加密数据的大小，如果存储在加密设备的末尾，就得把这段大小给抠掉

        if(!strcmp(key_loc, KEY_IN_FOOTER))

           crypt_ftr.fs_size = nr_sec - (CRYPT_FOOTER_OFFSET /

                                          CRYPT_SECTOR_SIZE);

        else crypt_ftr.fs_size = nr_sec;

       crypt_ftr.flags |= CRYPT_INCONSISTENT_STATE;

       crypt_ftr.crypt_type = crypt_type;

#ifndef CONFIG_HW_DISK_ENCRYPTION

        //设置加密算法，硬件最好支持，否则这速度上不去啊！

       strlcpy((char *)crypt_ftr.crypto_type_name,"aes-cbc-essiv:sha256",

                          MAX_CRYPTO_TYPE_NAME_LEN);

#else

       ......

#endif

       //光有password作为key还不够，我们还需要加入盐值，最终会搞到keymaster里边得到

      //一组密钥。相关基础知识可参考我博客中的关于JavaSecurity方面的文章2篇！

       create_encrypted_random_key(passwd, crypt_ftr.master_key,

                 crypt_ftr.salt, &crypt_ftr))

      //把这些信息存到key位置或者存储空间的最末尾

      put_crypt_ftr_and_key(&crypt_ftr);

        if(!persist_data) {

          pdata = malloc(CRYPT_PERSIST_DATA_SIZE);

          if (pdata) {

              init_empty_persist_data(pdata, CRYPT_PERSIST_DATA_SIZE);

              persist_data = pdata;

           }

        }

        //好吧，其实key信息是存储了两份，挨着的。还是怕出事啊。当第一份被破坏的时候，还能

        //从第二份那修复回来！

        if(persist_data) {

            save_persistent_data();

        }

    }

#prep_data_fs设置属性值为trigger_post_fs_data，

on property:vold.decrypt=trigger_post_fs_data

    triggerpost-fs-data #执行post-fs-data这一section所包含的命令

#post-fs-data重建了系统运行时候/data目录下所有必需的资源

on post-fs-data

    chown system system /data

    chmod0771 /data

    restorecon /data

    copy /data/system/entropy.dat /dev/urandom

    mkdir /data/dontpanic 0750 root log

    copy /proc/apanic_console/data/dontpanic/apanic_console

    chown root log/data/dontpanic/apanic_console

    chmod 0640 /data/dontpanic/apanic_console

    ......

    mkdir /data/misc/zoneinfo 0775 systemsystem

    mkdir /data/misc/vpn 0770 system vpn

    ......

if (how == CRYPTO_ENABLE_INPLACE) {

   //这个动作会触发class main类型的service重启动，当然，zygote也就起来了

   //然后framework都起来了。但是由于SystemServer只加载coreApp，所以我们能看见

   //图6

   property_set("vold.decrypt", "trigger_restart_min_framework");

   }

    decrypt_master_key(passwd,decrypted_master_key, &crypt_ftr, 0, 0);

    /*

      利用device-mapper机制创建一个

      1 device mapper设备，其实device mapper是一个驱动，叫md（mapped device之意）

      2 为这个device mapper设备设置一个crypt虚拟项。这个crypt虚拟项会和

        待加密设备（real_blkdev）关联起来.

      3 crypto_blkdev是上面device mapper创建的一个虚拟项设备，命名方式为

        /dev/block/dm-xxx。xxx为device mapper的minor版本号。

      4 设备加解密工作就是在这个crypto_blkdev读写过程中完成的。以后我们挂载这个

       crypto_blkdev到/data分区就可以了。当从这个设备读的时候，它会从底层关联的

       real_blkdev读取加密数据，然后解密传递给读者。当往这个设备写的时候，它会加密后

       再写到real_blkdev中

   */

    create_crypto_blk_dev(&crypt_ftr, decrypted_master_key, real_blkdev,

              crypto_blkdev,"userdata");

    /* If weare continuing, check checksums match */

    rc = 0;

    ......

    if (!rc){

        /*

          加密数据。方法很简单，从real_blkdev读取数据，然后写到crypto_blkdev中。

          前面反复讲过了。real_blkdev实际上是和crypto_blkdev绑定好的。

          1 我们先从real_blkdev中读取未加密的数据，从存储空间第一块位置开始读取

          2 然后写到crypto_bldev中。它会先加密，然后对应写回到real_blkdev第一块位置

        */

        rc =cryptfs_enable_all_volumes(&crypt_ftr, how,

                                       crypto_blkdev, real_blkdev,

                                       previously_encrypted_upto);

    }

   ......

    //删除crypto_blk_dev设备

   delete_crypto_blk_dev("userdata");

   free(vol_list);

    if (!rc) {

       crypt_ftr.flags &= ~CRYPT_INCONSISTENT_STATE;

        if(how == CRYPTO_ENABLE_INPLACE

             && crypt_ftr.encrypted_upto != crypt_ftr.fs_size) {

            //如果加密进度不等于整体数据大小，则设置一个标志位

            crypt_ftr.flags |= CRYPT_ENCRYPTION_IN_PROGRESS;

        }

        //保存加密信息上下文到指定位置

        put_crypt_ftr_and_key(&crypt_ftr);

        if (how == CRYPTO_ENABLE_WIPE

             || crypt_ftr.encrypted_upto== crypt_ftr.fs_size) {

          //如果加密完毕，encyrpted_upto将等于fs_size。注意下面这个流程：

         char value[PROPERTY_VALUE_MAX];

         /*

          获取ro.crypto.state的属性，这个属性：

          1 如果值为空：表明是强制加密设备的第一次加密。那么我们要挂载这个已经加密的设备

          2 如果值不为空（此时值应该是“uncrypted”，在init中设置），表明我们是对

            以前没有加密的设备进行首次加密

         */

         property_get("ro.crypto.state", value, "");

          if(!strcmp(value, "")) {

            property_set("ro.crypto.state","encrypted");

           release_wake_lock(lockid);

           //挂载加密设备，先检查默认密码是不是对的

            cryptfs_check_passwd(DEFAULT_PASSWORD);

            cryptfs_restart_internal(1);

           return 0;

          } else {

           //对于其他情况，则重启机器。这里sleep 2秒的原因是让大家有机会看到

           //图6中加密进度能到100的情况！

           sleep(2);

           cryptfs_reboot(reboot);

          }

        }else {

           sleep(2);

           cryptfs_reboot(shutdown);

        }

    } ......

 ......

    return-1;

}

static int create_crypto_blk_dev(structcrypt_mnt_ftr *crypt_ftr,

        unsigned char *master_key,char*real_blk_name, char *crypto_blk_name,

        const char *name)

{

  charbuffer[DM_CRYPT_BUF_SIZE];

  charmaster_key_ascii[129];

  char*crypt_params;

  struct dm_ioctl *io;//发送给devicemapper的命令，都是通过ioctl来完成的

  //为mapped device设置目标，也就是建立虚拟项和实际设备的关系

  struct dm_target_spec *tgt;

  unsignedint minor;

  int fd=0; inti; int retval = -1; int version[3];

  char*extra_params; int load_count;

  //打开/dev/device-mapper，这个设备对应的驱动在kernel/drivers/md目录下。我们

  //后续会简单分析下它

  fd =open("/dev/device-mapper",O_RDWR);

  io =(struct dm_ioctl *) buffer;

 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);

  //创建一个mappeddevice

  ioctl(fd, DM_DEV_CREATE, io);

  //获取这个mappeddevice的状态，其实就是版本号之类的东西

 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);

  ioctl(fd, DM_DEV_STATUS, io);

  minor =(io->dev & 0xff) | ((io->dev >> 12) & 0xfff00);

  snprintf(crypto_blk_name,MAXPATHLEN, "/dev/block/dm-%u", minor);

 extra_params = "";

  //一个mapped device可以注册多个虚拟项，这被称作target项。在驱动中，一个叫"crypt"的

  //target项会注册到这个mapped device中。下面这个函数就是找到这个MD设备注册的crypt项

  //的版本信息

  if (! get_dm_crypt_version(fd, name, version)) {

       ......

  }

  //建立target项和真实待加密设备（real_blk_name）的关系，然后把这个映射关系加载到MD里

  //在这个函数中，我们会把key相关信息存到target项里去。

 //注意，本文没有介绍具体的加解密算法，所以这里key的类型其实从来也没讨论过！

  load_count= load_crypto_mapping_table(crypt_ftr,master_key, real_blk_name,

                         name, fd,extra_params);

   ......

 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);

  ioctl(fd,DM_DEV_SUSPEND, io);

  retval =0;

  ...

  returnretval;

}

static int load_crypto_mapping_table(structcrypt_mnt_ftr *crypt_ftr,

                 unsigned char *master_key,char*real_blk_name,

                 const char *name, int fd, char*extra_params)

{

  charbuffer[DM_CRYPT_BUF_SIZE];

  structdm_ioctl *io; struct dm_target_spec *tgt;

  char*crypt_params; char master_key_ascii[129];

  int i;

  io =(struct dm_ioctl *) buffer;

  tgt =(struct dm_target_spec *) &buffer[sizeof(struct dm_ioctl)];

 ioctl_init(io, DM_CRYPT_BUF_SIZE, name, 0);

  //设置映射表所需参数

 io->target_count = 1;

 tgt->status = 0;

 tgt->sector_start = 0;

 tgt->length = crypt_ftr->fs_size;

#ifdef CONFIG_HW_DISK_ENCRYPTION

  //设置target的名字其实，crypt或者req-crypt，到时候MD会根据这个名字找到对应的target

  if(!strcmp((char *)crypt_ftr->crypto_type_name, "aes-xts")) {

    strlcpy(tgt->target_type,"req-crypt", DM_MAX_TYPE_NAME);

  }

  else {

    strlcpy(tgt->target_type, "crypt",DM_MAX_TYPE_NAME);

  }

#else

 strlcpy(tgt->target_type, "crypt", DM_MAX_TYPE_NAME);

#endif

 crypt_params = buffer + sizeof(struct dm_ioctl) +

              sizeof(struct dm_target_spec);

 convert_key_to_hex_ascii(master_key, crypt_ftr->keysize,master_key_ascii);

  //把加密算法，key信息，真实设备名按指定格式存储好，

  sprintf(crypt_params, "%s%s 0 %s 0 %s", crypt_ftr->crypto_type_name,

          master_key_ascii, real_blk_name, extra_params);

 crypt_params += strlen(crypt_params) + 1;

 crypt_params = (char *) (((unsigned long)crypt_params + 7) & ~8);

 tgt->next = crypt_params - buffer;

  //加载映射表，多试几次！

  for (i =0; i < TABLE_LOAD_RETRIES; i++) {

    if (!ioctl(fd, DM_TABLE_LOAD, io)) {

      break;

    }

   usleep(500000);

  }

   ......

}

int cryptfs_mount_default_encrypted(void)

{

    chardecrypt_state[PROPERTY_VALUE_MAX];

   property_get("vold.decrypt", decrypt_state, "0");

    if(!strcmp(decrypt_state, "0")) {

       SLOGE("Not encrypted - should not call here");

    } else {

        intcrypt_type = cryptfs_get_password_type();

        if(crypt_type < 0 || crypt_type > CRYPT_TYPE_MAX_TYPE) {

           SLOGE("Bad crypt type - error");

        }else if (crypt_type != CRYPT_TYPE_DEFAULT) {

            //如果密码类型不是默认的，则启动framework，弹出图8

           property_set("vold.decrypt","trigger_restart_min_framework");

           return 0;

        }else if (cryptfs_check_passwd(DEFAULT_PASSWORD)== 0) {

           //先检查密码是否正确，然后再做后续处理！

            cryptfs_restart_internal(0);

            return 0;

        }else {

           SLOGE("Encrypted, default crypt type but can't decrypt");

        }

    }

   //其他错误处理

   property_set("vold.decrypt","trigger_restart_min_framework");

    return0;

}

static int cryptfs_restart_internal(intrestart_main)

{

    charfs_type[32]; char real_blkdev[MAXPATHLEN];

    charcrypto_blkdev[MAXPATHLEN]; char fs_options[256];

    unsignedlong mnt_flags; struct stat statbuf;

    int rc =-1, i;

    staticint restart_successful = 0;

    ......

    if(restart_main) {

        ......//shutdown framework相关模块

       property_set("vold.decrypt", "trigger_reset_main");

       SLOGD("Just asked init to shut down class main\n");

        sleep(2);

    }

   //获取虚拟的加密设备，也就是/dev/block/dm-xxx

   property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev,"");

    .....

    //先卸载/data/目前的挂载

    if (!(rc = wait_and_unmount(DATA_MNT_POINT,true)) ) {

        ......

        int retries = RETRY_MOUNT_ATTEMPTS;

        intmount_rc;

        //把crypto_blkdev挂载到/data上

       while ((mount_rc = fs_mgr_do_mount(fstab,DATA_MNT_POINT,

                                           crypto_blkdev, 0))

              != 0) {

              ......

        }

       property_set("vold.decrypt", "trigger_load_persist_props");

        /*Create necessary paths on /data */

        if (prep_data_fs()) {

           return -1;

        }

        //重启framework，这时候设置的属性值不再会导致SystemServer只加载coreApp了

       property_set("vold.decrypt", "trigger_restart_framework");

       SLOGD("Just triggered restart_framework\n");

       ......

    }

    ......

    returnrc;

}

   //打开MD驱动

   open("/dev/device-mapper",O_RDWR)

   //创建一个MD设备

    ioctl(fd,DM_DEV_CREATE, io)

   //获取MD支持的各种target

   ioctl(fd, DM_LIST_VERSIONS, io)

    //设置映射表，当然，我们这里只对crypt目标设置映射表

   ioctl(fd, DM_TABLE_LOAD, io)

   //暂停MD设备

   ioctl(fd, DM_DEV_SUSPEND, io)

    //挂载crypt block设备，这是一个虚拟出来的设备

   mount(crypto_blk_dev)

static int __initdm_init(void)

{

    const int count = ARRAY_SIZE(_inits);//一组需要初始化的函数

    int r, i;

    for (i = 0; i < count; i++) {

        r = _inits[i]();

        ......

    }

    return 0;

    ......

}

static int (*_inits[])(void) __initdata = {

    local_init,//在这里将注册一个block device

    dm_target_init,

    dm_linear_init,

    dm_stripe_init,

    dm_io_init,

    dm_kcopyd_init,

    dm_interface_init,//在这里注册一个misc device

};

int __initdm_interface_init(void)

{

    int r;

    r = dm_hash_init();

    r = misc_register(&_dm_misc);

    .....

    DMINFO("%d.%d.%d%s initialised:%s", DM_VERSION_MAJOR,

           DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL,DM_VERSION_EXTRA,

           DM_DRIVER_EMAIL);

    return 0;

}

static structmiscdevice _dm_misc = {

    .minor        = MAPPER_CTRL_MINOR,

    .name         = DM_NAME,

    .nodename   = DM_DIR "/" DM_CONTROL_NODE,

    .fops         = &_ctl_fops//用户空间open/ioctl等函数在driver中的实现

};

static const structfile_operations _ctl_fops = {

    .open = nonseekable_open,

    .unlocked_ioctl     = dm_ctl_ioctl,

    .compat_ioctl = dm_compat_ctl_ioctl,//ioctl函数对应的实现

    .owner    = THIS_MODULE,

    .llseek = noop_llseek,

};

static ioctl_fnlookup_ioctl(unsigned int cmd)

{

    static struct {

        int cmd;

        ioctl_fn fn;

    } _ioctls[] = {

        {DM_VERSION_CMD, NULL},    /* version is dealt with elsewhere */

        {DM_REMOVE_ALL_CMD, remove_all},

        {DM_LIST_DEVICES_CMD, list_devices},

        {DM_DEV_CREATE_CMD, dev_create},

        {DM_DEV_REMOVE_CMD, dev_remove},

        {DM_DEV_RENAME_CMD, dev_rename},

        {DM_DEV_SUSPEND_CMD, dev_suspend},

        {DM_DEV_STATUS_CMD, dev_status},

        {DM_DEV_WAIT_CMD, dev_wait},

        {DM_TABLE_LOAD_CMD, table_load},

        {DM_TABLE_CLEAR_CMD, table_clear},

        {DM_TABLE_DEPS_CMD, table_deps},

        {DM_TABLE_STATUS_CMD, table_status},

        {DM_LIST_VERSIONS_CMD,list_versions},

        {DM_TARGET_MSG_CMD, target_message},

        {DM_DEV_SET_GEOMETRY_CMD,dev_set_geometry}

    };

    return (cmd >= ARRAY_SIZE(_ioctls)) ?NULL : _ioctls[cmd].fn;

}

int dm_create(intminor, struct mapped_device **result)

{

    struct mapped_device *md;

    md = alloc_dev(minor);

    ......

    dm_sysfs_init(md);

    *result = md;

    return 0;

}

static structmapped_device *alloc_dev(int minor)

{

    int r;

    struct mapped_device *md = kzalloc(sizeof(*md), GFP_KERNEL);

    void *old_md;

    ......

    if (minor == DM_ANY_MINOR)

        r = next_free_minor(&minor);

    else

        r = specific_minor(minor);

    md->type = DM_TYPE_NONE;

    ......

    md->queue = blk_alloc_queue(GFP_KERNEL);

    dm_init_md_queue(md);

    md->disk = alloc_disk(1);

    .....

    md->disk->major = _major;

    md->disk->first_minor = minor;

    md->disk->fops = &dm_blk_dops; //设置block device的函数实现

    md->disk->queue = md->queue;

    md->disk->private_data= md;

    //block设备的名字，前面见过了

    sprintf(md->disk->disk_name, "dm-%d", minor);

    add_disk(md->disk);

    format_dev_t(md->name, MKDEV(_major,minor));

    md->wq =alloc_workqueue("kdmflush",

                 WQ_NON_REENTRANT | WQ_MEM_RECLAIM, 0);

    md->bdev = bdget_disk(md->disk, 0);

    ......

    return md;

    ......

}

static int __initdm_crypt_init(void)

{

    int r;

    _crypt_io_pool = KMEM_CACHE(dm_crypt_io,0);

    r = dm_register_target(&crypt_target);

   ....

    return r;

}

static structtarget_type crypt_target = {

    .name   ="crypt",//这就是前面见过的crypt target

    .version = {1, 11, 0},

    .module = THIS_MODULE,

    .ctr   = crypt_ctr,//初始化构造函数，这个要到设置映射表的时候才会被调用

    .dtr   = crypt_dtr,

    .map   = crypt_map,

    .status = crypt_status,

    .postsuspend = crypt_postsuspend,

    .preresume = crypt_preresume,

    .resume = crypt_resume,

    .message = crypt_message,

    .merge = crypt_merge,

    .iterate_devices = crypt_iterate_devices,

};

static inttable_load(struct dm_ioctl *param, size_t param_size)

{

    int r;struct hash_cell *hc;struct dm_table*t;

    struct mapped_device *md;

    struct target_type *immutable_target_type;

    md =find_device(param);

    //分配映射表。本例中，target_count值为1

    r = dm_table_create(&t, get_mode(param), param->target_count, md);

    ....

    //根据参数来初始化映射表

    r = populate_table(t, param, param_size);

    ....

    return r;

}

static intpopulate_table(struct dm_table *table,

              struct dm_ioctl *param, size_t param_size)

{

    int r;

    unsigned int i = 0;

    struct dm_target_spec *spec = (structdm_target_spec *) param;

    uint32_t next = param->data_start;

    void *end = (void *) param + param_size;

    char *target_params;

    for (i = 0; i < param->target_count;i++) {

        r = next_target(spec, next, end,&spec, &target_params);

        .....

       //target_type就是target的名字，此处为"crypt"，里边将把参数传递给

      //crypt target的ctr函数

        r = dm_table_add_target(table, spec->target_type,

                    (sector_t)spec->sector_start,

                    (sector_t) spec->length,

                    target_params);

        .....

        }

        next = spec->next;

    }

    return dm_table_complete(table);

}

static voidcrypt_endio(struct bio *clone, int error)

{

    struct dm_crypt_io *io =clone->bi_private;

    struct crypt_config *cc =io->target->private;

    unsigned rw = bio_data_dir(clone);

    .....

    bio_put(clone);

    if (rw== READ && !error) {

       //这个io请求被加到一个workqueue里，对应的处理函数是kcryptd_crypt

        kcryptd_queue_crypt(io);

        return;

    }

    .....

}

static voidkcryptd_crypt(struct work_struct *work)

{

    struct dm_crypt_io *io = container_of(work,struct dm_crypt_io, work);

    if (bio_data_dir(io->base_bio) == READ)

        kcryptd_crypt_read_convert(io);

    else

        kcryptd_crypt_write_convert(io);

}

static intcrypt_map(struct dm_target *ti, struct bio *bio,

             union map_info *map_context)

{

    struct dm_crypt_io *io;

    struct crypt_config *cc;

     ......

    io = crypt_io_alloc(ti, bio,dm_target_offset(ti, bio->bi_sector));

    if (bio_data_dir(io->base_bio) == READ){

        if (kcryptd_io_read(io, GFP_NOWAIT))

            kcryptd_queue_io(io);

    } else

        //这个io请求被加到一个workqueue里，对应的处理函数是kcryptd_crypt

        kcryptd_queue_crypt(io);

   ....

   return 0;

}