使用Hikey960开发板

一、下载aosp和hikey-linaro的源码。

二、编译aosp源码和Hikey-linaro源码

一个脚本

#/bin/bash
cd /home/vup/aosp
source build/envsetup.sh && lunch hikey960-userdebug
#make -j 24

cd /home/vup/aosp/hikey-linaro
#export PATH=$PATH:/home/vup/aarch64-linux-android-4.9/bin/
make ARCH=arm64 hikey960_defconfig
make ARCH=arm64 CROSS_COMPILE=aarch64-linux-android- -j24

cp /home/vup/aosp/hikey-linaro/arch/arm64/boot/dts/hisilicon/hi3660-hikey960.dtb /home/vup/aosp/device/linaro/hikey-kernel/hi3660-hikey960.dtb-4.9

cp /home/vup/aosp/hikey-linaro/arch/arm64/boot/Image.gz /home/vup/aosp/device/linaro/hikey-kernel/Image.gz-hikey960-4.9

cd /home/vup/aosp/

make bootimage -j24

sz out/target/product/hikey960/boot.img

三、一些常用shell命令

am start -W  com.sina.weibo/.SplashActivity
am start -W com.tencent.mobileqq/.activity.SplashActivity
#启动微信
am start -W com.tencent.mm/.ui.LauncherUI
am force-stop com.tencent.mm
am force-stop  com.sina.weibo
echo 3 > /proc/sys/vm/drop_caches

四、一些骚错误

1. 没有SDCARD?

hikey-linaro/arch/arm64/configs/hikey960_defconfig
CONFIG_SDCARD_FS=y
ok

2. error: ‘vdso_offset_sigtramp’ undeclared

I’ve got the same error message but the cause is somewhat different. My include/generated/vdso-offsets.h is empty. The reason is that arch/arm64/kernel/vdso/gen_vdso_offsets.h does not have the eXecute permission.

3. git checkout -b的时候target exists

cd .git/refs/heads/

删除相应的分支即可

4.python版本的问题

问题

SyntaxError: Missing parentheses in call to 'print'. Did you mean print(int r)?

指定python2.7为默认的python。

5. 找不到头文件**.dtc

arch/arm/boot/dts/include/
ln -s ../../../../../include/dt-bindings dt-bindings

6.太多的printk卡死

使用proc虚拟文件系统

#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

static struct proc_dir_entry *proc_root; 
static struct proc_dir_entry *proc_entry; 
#define USER_ROOT_DIR "proc_test_root" 
#define USER_ENTRY "test_hello"
#define INFO_LEN 16

//the option of prefetch

//prefetch mode
#define no_prefetch 0
#define origin_prefetch 1
#define sk_associate_prefetch 2
#define all_prefetch 3

char * info;
extern atomic_t prefetch_mode;

extern atomic_t vup_miss;
extern atomic_t vup_hit;

extern atomic_t sk_prefetch_success_called_num;
extern atomic_t sk_prefetch_hit_count;
extern atomic_t prefetch_n;

//statistic hit and miss count
extern atomic_t sk_generic_cache_hit;
extern atomic_t sk_generic_cache_miss;
extern atomic_t sk_generic_cache_access;

extern atomic_t sk_fault_cache_hit;
extern atomic_t sk_fault_cache_miss;
extern atomic_t sk_fault_cache_access;

//statistic io num
extern atomic_t sk_generic_sync_io_num;
extern atomic_t sk_generic_async_io_num;
extern atomic_t sk_fault_sync_io_num;
extern atomic_t sk_fault_async_io_num;
extern atomic_t sk_associate_prefetch_io_num;


extern atomic_t vup_access_buff;

extern char *vup_log_buff;
extern unsigned long vup_buff_len;
extern atomic_t vup_buff_line;
extern atomic_t vup_buff_oom;

atomic_t vup_test_write_num=ATOMIC_INIT(0);

static int HitMissInfo(struct seq_file *m,void *v)
{
    int hitcount = atomic_read(&vup_hit);
    int misscount = atomic_read(&vup_miss);

    int prefetch_success_called_num = atomic_read(&sk_prefetch_success_called_num);
    //int prefetch_hit_count = atomic_read(&sk_prefetch_hit_count);
    int prefetch_num =  atomic_read(&prefetch_n);

  unsigned long tmp_buff_len;
    int tmp_buff_line,tmp_buff_oom,tmp_test_write_num;

    //statistic hit and miss count
    int generic_cache_hit=atomic_read(&sk_generic_cache_hit);
    int generic_cache_miss=atomic_read(&sk_generic_cache_miss);
    int generic_cache_access=atomic_read(&sk_generic_cache_access);

    int fault_cache_hit=atomic_read(&sk_fault_cache_hit);
    int fault_cache_miss=atomic_read(&sk_fault_cache_miss);
    int fault_cache_access=atomic_read(&sk_fault_cache_access);

    //statistic io num
    int generic_sync_io_num=atomic_read(&sk_generic_sync_io_num);
    int generic_async_io_num=atomic_read(&sk_generic_async_io_num);
    int fault_sync_io_num=atomic_read(&sk_fault_sync_io_num);
    int fault_async_io_num=atomic_read(&sk_fault_async_io_num);
    int associate_prefetch_io_num=atomic_read(&sk_associate_prefetch_io_num);

    int mode = atomic_read(&prefetch_mode);

    seq_printf(m,"hitcount: %d\n",hitcount);
    seq_printf(m,"misscount:%d\n",misscount);
    seq_printf(m,"prefetch_success_called_num:%d\n",prefetch_success_called_num);
    seq_printf(m,"prefetch_page_num:%d\n",prefetch_num);

    seq_printf(m,"generic_cache_hit: %d\n",generic_cache_hit);
    seq_printf(m,"generic_cache_miss:%d\n",generic_cache_miss);
    seq_printf(m,"generic_cache_access:%d\n",generic_cache_access);
    seq_printf(m,"fault_cache_hit: %d\n",fault_cache_hit);
    seq_printf(m,"fault_cache_miss:%d\n",fault_cache_miss);
    seq_printf(m,"fault_cache_access:%d\n",fault_cache_access);
    seq_printf(m,"generic_sync_io_num:%d\n",generic_sync_io_num);
    seq_printf(m,"generic_async_io_num: %d\n",generic_async_io_num);
    seq_printf(m,"fault_sync_io_num:%d\n",fault_sync_io_num);
    seq_printf(m,"fault_async_io_num:%d\n",fault_async_io_num); 
    seq_printf(m,"associate_prefetch_io_num:%d\n",associate_prefetch_io_num); 
    seq_printf(m,"prefetch_mode:%d\n",mode); 


  if(vup_log_buff&&atomic_add_unless(&vup_access_buff,1,1))
  {
        seq_printf(m,"\ntrace_content:%s\n",vup_log_buff);
            tmp_buff_len=vup_buff_len;
            tmp_buff_line=atomic_read(&vup_buff_line);
            tmp_buff_oom=atomic_read(&vup_buff_oom);
            tmp_test_write_num=atomic_read(&vup_test_write_num);
            seq_printf(m,"vup_buff_len:%lu ,vup_buff_line:%d vup_buff_oom:%d,current_test_write_num=%d\n",tmp_buff_len,tmp_buff_line,tmp_buff_oom,vup_test_write_num);
            //printk("already add traceinfo into buffer yet, current len=%lu",vup_buff_len); 

      atomic_set(&vup_access_buff,0);
  }

    return 0;
}

static int proc_test_show(struct seq_file *m, void *v)
{
  //seq_printf(m, "%s\n",info);
  HitMissInfo(m,v);
  return 0;
}

static int proc_test_open(struct inode *inode, struct file *file)
{
  return single_open(file, proc_test_show, NULL);
}

static ssize_t proc_test_write(struct file *file, const char __user *buffer,  size_t count, loff_t *f_pos) 
{ 
   if(vup_log_buff&&atomic_add_unless(&vup_access_buff,1,1))
   {
        atomic_set(&vup_buff_oom,0);
        atomic_set(&vup_buff_line,0);
        printk("PROC_TEST:old_test_write_num:%d\n",atomic_read(&vup_test_write_num));
        atomic_inc(&vup_test_write_num);
        vup_buff_len=0;
        atomic_set(&vup_access_buff,0);
   }

   if( count > INFO_LEN)
       return -EFAULT;
   if(copy_from_user(info, buffer, count) == 0) 
   {
        //no prefetch   
        if(info[0]=='n')
        {
            atomic_set(&prefetch_mode,no_prefetch);
            printk("prefetch mode:%d\n",prefetch_mode);
        }
        //orgin     
        else if(info[0]=='o')
        {
            atomic_set(&prefetch_mode,origin_prefetch);
            printk("prefetch mode:%d\n",prefetch_mode);
        }
        //our associate rules
        else if(info[0]=='s')
        {
            atomic_set(&prefetch_mode,sk_associate_prefetch);
            printk("prefetch mode:%d\n",prefetch_mode);
        }
        //all prefetch (origin + our)
        else if(info[0]=='a')
        {
             atomic_set(&prefetch_mode,all_prefetch);
             printk("prefetch mode:%d\n",prefetch_mode);
        }
        else
        {
            printk("info %s\n",info);
        }
       return count;
   } 
   return -EFAULT; 
} 

static const struct file_operations proc_test_fops = 
{
    .owner  = THIS_MODULE,
    .open   = proc_test_open,
    .read   = seq_read,
    .write = proc_test_write,
    .llseek = seq_lseek,
    .release    = single_release,
};

static int test_create_proc_entry(void)
{
  int error = 0;
  proc_root = proc_mkdir(USER_ROOT_DIR, NULL); 
  if (NULL==proc_root) 
  { 
    printk(KERN_ALERT"Create dir /proc/%s error!\n", USER_ROOT_DIR); 
    return -ENOMEM; 
  } 
    printk(KERN_INFO"Create dir /proc/%s\n", USER_ROOT_DIR); 

  // proc_entry =create_proc_entry(USER_ENTRY, 0666, proc_root); 
  proc_entry = proc_create(USER_ENTRY, 0666, proc_root, &proc_test_fops);

  if (NULL ==proc_entry) 
  { 
    printk(KERN_ALERT"Create entry %s under /proc/%s error!\n", USER_ENTRY,USER_ROOT_DIR); 
    error = -ENOMEM;
    goto err_out;

  }

//proc_entry->write_proc= fellow_writeproc;
//proc_entry->read_proc = fellow_readproc;
  printk(KERN_INFO"Create /proc/%s/%s\n", USER_ROOT_DIR,USER_ENTRY); 
  return 0; 
err_out: 
//proc_entry->read_proc = NULL; 
//proc_entry->write_proc= NULL;
  remove_proc_entry(USER_ENTRY, proc_root);
  remove_proc_entry(USER_ROOT_DIR, NULL); 
  return error; 
}

static int proc_test_init(void)
{
  int ret = 0;
  printk("proc_test_init\n");

  info = kmalloc(INFO_LEN * sizeof(char), GFP_KERNEL);
  if (!info)
  {
    ret = -ENOMEM;
    goto fail;
  }
  memset(info, 0, INFO_LEN);
  test_create_proc_entry();
  return 0;
fail:
  return ret;
}

static void proc_test_exit(void)
{
  kfree(info);

  remove_proc_entry(USER_ENTRY, proc_root);
  remove_proc_entry(USER_ROOT_DIR, NULL); 
}

MODULE_AUTHOR("proc_test");
MODULE_LICENSE("GPL");
module_init(proc_test_init);
module_exit(proc_test_exit);