Frantic log#1048

git clone --recurse-submodules https://github.com/qmk/qmk_firmware

make org60-boardy-dfu

/* 板子对应的头文件 */
#include "org60.h"

/* 各个 Layer 的映射 */
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = KEYMAP( /* xxx */ ),
    [1] = KEYMAP( /* xxx */ ),
    /* 更多的层... */
};

/* 各个 Fn 键的操作 */
const uint16_t PROGMEM fn_actions[] = {
    [0] = ACTION_FUNCTION(0), /* 戳 Fn0 -> 调用 action_function 进行自定义的操作 */
};

void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
    /* 这个 id 就是 ACTION_FUNCTION 里的参数 */
    switch (id) {
        case 0:
            /* 戳 Fn0 的操作就在这里处理了 */
            /* ... */
        break;
    }
}

+---------------------------------------------------------------------+
|EFI System|Root                                  |Swap               |
|/boot/efi |/                                     |Swap               |
|FAT32     |Btrfs                                 |Swap!!!            |
|          +-------------------+------------------+-------------------+
|          |LUKS container     |LUKS container    |LUKS container     |
|          |/dev/mapper/cryroot|/dev/mapper/cryext|/dev/mapper/cryswap|
+----------+-------------------+------------------+-------------------+
|Partition |Partition          |Partition         |Partition          |
|/dev/sdb1 |/dev/sdb2          |/dev/sda1         |/dev/sda2          |
+----------+-------------------+------------------+-------------------+
|20GB SSD                      |500GB HDD                             |
|GPT                           |GPT                                   |
|/dev/sdb                      |/dev/sda                              |
+---------------------------------------------------------------------+

ssh root@10.50.136.233 "dd if=/dev/sda" | dd status=progress of=~/onmybackup/sda.img
ssh root@10.50.136.233 "dd if=/dev/sdb" | dd status=progress of=~/onmybackup/sdb.img

cryptsetup open --type plain /dev/sda containera --key-file /dev/random
cryptsetup open --type plain /dev/sdb containerb --key-file /dev/random

+----------+-------------------+------------------+-------------------+
|LUKS container                |LUKS container                        |
|/dev/mapper/containera        |/dev/mapper/containerb                |
+----------+-------------------+------------------+-------------------+
|20GB SSD                      |500GB HDD                             |
|GPT                           |GPT                                   |
|/dev/sdb                      |/dev/sda                              |
+---------------------------------------------------------------------+

dd if=/dev/zero of=/dev/mapper/containera status=progress
dd if=/dev/zero of=/dev/mapper/containerb status=progress

cryptsetup close containera
cryptsetup close containerb

+----------+-------------------+------------------+-------------------+
|Partition |Partition          |Partition         |Partition          |
|/dev/sdb1 |/dev/sdb2          |/dev/sda1         |/dev/sda2          |
+----------+-------------------+------------------+-------------------+
|20GB SSD                      |500GB HDD                             |
|GPT                           |GPT                                   |
|/dev/sdb                      |/dev/sda                              |
+---------------------------------------------------------------------+

cryptsetup luksFormat /dev/sdb2
cryptsetup luksFormat /dev/sda1
cryptsetup luksFormat /dev/sda2

cryptsetup open --type luks /dev/sdb2 cryroot
cryptsetup open --type luks /dev/sda1 cryext
cryptsetup open --type luks /dev/sda2 cryswap

+----------+-------------------+------------------+-------------------+
|          |LUKS container     |LUKS container    |LUKS container     |
|          |/dev/mapper/cryroot|/dev/mapper/cryext|/dev/mapper/cryswap|
+----------+-------------------+------------------+-------------------+
|Partition |Partition          |Partition         |Partition          |
|/dev/sdb1 |/dev/sdb2          |/dev/sda1         |/dev/sda2          |
+----------+-------------------+------------------+-------------------+
|20GB SSD                      |500GB HDD                             |
|GPT                           |GPT                                   |
|/dev/sdb                      |/dev/sda                              |
+---------------------------------------------------------------------+

mount /dev/mapper/cryroot /mnt
mkdir /mnt/boot/efi
mount /dev/sdb1 /mnt/boot/efi

losetup -P /dev/loop0 ~/onmybackup/sda.img
losetup -P /dev/loop1 ~/onmybackup/sdb.img

rsync -SPAaXr PATH_TO_ROOT root@10.50.136.233:/mnt/
rsync -SPAaXr PATH_TO_HOME root@10.50.136.233:/mnt/home/
#...

GRUB_CMDLINE_LINUX="cryptdevices=/dev/sdb2:cryroot;/dev/sda2:cryext;/dev/sda1:cryswap"

mkinitcpio -p linux-zen
grub-mkconfig -o /boot/grub/grub.cfg
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=grub

genfstab /mnt >> /mnt/etc/fstab

// 引入 Fetch API 的 polyfill，

// 确保在遇到不支持的浏览器上一切正常运行。

// https://github.com/matthew-andrews/isomorphic-fetch/

import 'isomorphic-fetch';

export const types = {
  FETCH_POST_REQUEST: 'FETCH_POST_REQUEST',
  FETCH_POST_SUCCESS: 'FETCH_POST_SUCCESS',
  FETCH_POST_FAILURE: 'FETCH_POST_FAILURE',
};

// 发起文章请求的 action，

// 包含一个 postId 标识准备请求哪篇文章，

// 可用于在 store 中标识拉取状态。

const fetchPostRequest = (postId) => ({
  type: types.FETCH_POST_REQUEST,
  payload: postId,
});

// 成功接收文章的 action，

// 包含一个 post 属性，里面存储了接收的文章内容以及 postId。

const fetchPostSuccess = ({id, content}) => ({
  type: types.FETCH_POST_SUCCESS,
  payload: {id, content},
});

const fetchPostFailure = ({id, failedResponse}) => ({
  type: types.FETCH_POST_FAILURE,
  payload: {id, failedResponse},
});

// 用来发请求的 action creator 返回一个函数，

// 称之为 thunk action，会被 Redux Thunk 中间件接手

// 使用的时候和普通 action 一样：

// store.dispatch(fetchPost(postId))

export const fetchPost = (postId) => (dispatch) => {

  // 这个返回的函数会被 Redux Thunk 中间件执行，

  // 同时会在第一个参数接收到 redux store 的 `dispatch` 方法，

  // 从而可以在这里面自己触发 action。


  // 先触发一个准备发请求的 action，

  dispatch(fetchPostRequest(postId));

  return fetch(`/posts/${postId}.md`)
    .then(response => response.text())
    .then(content => fetchPostSuccess({id: postId, content}))
    .catch(failedResponse => fetchPostFailure({id: postId, failedResponse}));
}

// 用 redux-mock-store 来模拟一个 store 并检查是否触发了预期的 action

// https://github.com/arnaudbenard/redux-mock-store

import configureMockStore from 'redux-mock-store';

// 用来处理我们的 thunk action 的中间件

// https://github.com/gaearon/redux-thunk

import thunk from 'redux-thunk';

// 用 sinon 来伪造 fetch API。

// 如果在 Karma 配置中设定了 frameworks: [... ,'sinon']，

// 则不需要再写这句 import 了。

// http://sinonjs.org/

import sinon from 'sinon';

// 上面写的 actions.js

import {types, fetchPost} from '../actions';

const middlewares = [ thunk ];
const mockStore = configureMockStore(middlewares);

describe('Post fetching', () => {
  // 用作测试的文章 id 及其内容

  const testPostId = 223;
  const testPostContent = 'Gochuumon wa usagi desu ka ???';

  describe('succeed', () => {
    // 创建一个包含文章内容的成功响应

    const res = new window.Response(testPostContent, {
      status: 200,
      headers: { 'Content-type': 'text/plain' },
    });

    beforeAll(() => {
      // 把原来的 fetch 包成 stub，

      // 这样做原来的 window.fetch 就不会被调用了

      sinon.stub(window, 'fetch');

      // 这里调用的 window.fetch 已经是 sinon 的 stub function 了，

      // 可以通过 withArgs 与 returns 方法

      // 来指定函数在接受到什么参数的时候返回什么。

      // 这里指定请求正确的文章 URL 的时候

      // 返回对应的请求成功的响应

      window.fetch
        .withArgs(`/posts/${testPostId}.md`)
        .returns(Promise.resolve(res));
    })

    afterAll(() => {
      // 执行完这组用例后恢复原来的 window.fetch 函数。

      window.fetch.restore();
    })

    it('should FETCH_POST_SUCCESS with post content', (done) => {
      // 期望的发起请求的 action

      const actRequest = {
        type: types.FETCH_POST_REQUEST,
        payload: testPostId,
      };

      // 期望的请求成功的 action

      const actSuccess = {
        type: types.FETCH_POST_SUCCESS,
        payload: {id: testPostId, content: testPostContent},
      };

      const expectedActions = [
        actRequest,
        actSuccess,
      ];

      // store 的初始状态

      const initialState = {};

      // 如果触发了期望的 action 的话，

      // done 会被调用，表明这个测试用例通过了。

      const store = mockStore(initialState);

      // 准备好模拟的 store 后，

      // 触发请求文章的 action ～

      store.dispatch(fetchPost(testPostId))
        .then(() => {
          expect(store.getActions())
            .toEqual(expectedActions);
        })
        .then(done)
        .catch(done.fail);
    });
  });

  describe('failed', () => {
    // 和请求成功的情况类似，先创建一个失败的响应比如 404。

    const res = new window.Response('', { status: 404 });

    beforeAll(() => {
      sinon.stub(window, 'fetch');
      window.fetch
        .withArgs(`/posts/${testPostId}.md`)
        .returns(Promise.reject(res)); // 失败的请求应该用 Promise.reject()

    });

    afterAll(() => {
      window.fetch.restore();
    });

    it('should FETCH_POST_FAILURE with errored response', (done) => {
      const actRequest = {
        type: types.FETCH_POST_REQUEST,
        payload: testPostId,
      };

      const actFailure = {
        type: types.FETCH_POST_FAILURE,
        payload: {id: testPostId, failedResponse: res},
      };

      const expectedActions = [
        actRequest,
        actFailure,
      ];

      const store = mockStore({});
      store.dispatch(fetchPost(testPostId))
        .then(() => {
          expect(store.getActions())
            .toEqual(expectedActions);
        })
        .then(done)
        .catch(done.fail);
    });
  });
});

--- a/drivers/hid/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -2426,6 +2426,17 @@ void wacom_setup_device_quirks(struct wacom *wacom)
     }
 
    /*
+   * Hack for the Bamboo One:
+    * the device presents a PAD/Touch interface as most Bamboos and even
+    * sends ghosts PAD data on it. However, later, we must disable this
+    * ghost interface, and we can not detect it unless we set it here
+    * to WACOM_DEVICETYPE_PAD or WACOM_DEVICETYPE_TOUCH.
+    */
+   if (features->type == BAMBOO_PEN &&
+       features->pktlen == WACOM_PKGLEN_BBTOUCH3)
+       features->device_type |= WACOM_DEVICETYPE_PAD;
+
+   /*
      * Raw Wacom-mode pen and touch events both come from interface
     * 0, whose HID descriptor has an application usage of 0xFF0D
     * (i.e., WACOM_VENDORDEFINED_PEN). We route pen packets back
-- 

sudo pacman -S abs
sudo abs
sudo abs linux
cp -r /var/abs/core/linux ~/arch_packages/

makepkg -o # 这个选项下 makepkg 只会下载校验解压好所有源代码/资源文件

==> Verifying source file signatures with gpg...
    linux-4.5.tar ... FAILED (unknown public key 79BE3E4300411886)
    patch-4.5.1 ... FAILED (unknown public key 38DBBDC86092693E)

# $Id: PKGBUILD 265148 2016-04-19 06:55:26Z tpowa $

# Maintainer: Tobias Powalowski <tpowa@archlinux.org>

# Maintainer: Thomas Baechler <thomas@archlinux.org>


#pkgbase=linux               # Build stock -ARCH kernel

pkgbase=linux-Kafuu       # Build kernel with a different name

_srcname=linux-4.5
pkgver=4.5.1
pkgrel=1
arch=('i686' 'x86_64')
url="http://www.kernel.org/"
license=('GPL2')
makedepends=('xmlto' 'docbook-xsl' 'kmod' 'inetutils' 'bc')
options=('!strip')
source=("https://www.kernel.org/pub/linux/kernel/v4.x/${_srcname}.tar.xz"
        "https://www.kernel.org/pub/linux/kernel/v4.x/${_srcname}.tar.sign"
        "https://www.kernel.org/pub/linux/kernel/v4.x/patch-${pkgver}.xz"
        "https://www.kernel.org/pub/linux/kernel/v4.x/patch-${pkgver}.sign"
        # the main kernel config files

        'config' 'config.x86_64'
        # standard config files for mkinitcpio ramdisk

        'linux.preset'
        'change-default-console-loglevel.patch'
        'fix-Bamboo-ONE-oops.patch')

sha256sums=('a40defb401e01b37d6b8c8ad5c1bbab665be6ac6310cdeed59950c96b31a519c'
            'SKIP'
            '060ad091ebfa2b63d62e86beaf68c3a5d4638c506c3ac941c1825ba756e830b1'
            'SKIP'
            '8a8a955f015ee8342701231a63836cec0e300fd7e96d30e8696fde8a383fcdc9'
            '8b60911aad591306336e300e27071f2d108c5016e66a04327b82ac69acbfefff'
            'f0d90e756f14533ee67afda280500511a62465b4f76adcc5effa95a40045179c'
            '1256b241cd477b265a3c2d64bdc19ffe3c9bbcee82ea3994c590c2c76e767d99'
            '7dec753db812bd8a268e50d97cb1704b4ed097746e423720f6872ecf4a14e78c')
validpgpkeys=(
              'ABAF11C65A2970B130ABE3C479BE3E4300411886' # Linus Torvalds

              '647F28654894E3BD457199BE38DBBDC86092693E' # Greg Kroah-Hartman

             )

_kernelname=${pkgbase#linux}

prepare() {
  cd "${srcdir}/${_srcname}"

  # add upstream patch

  patch -p1 -i "${srcdir}/patch-${pkgver}"

  # add latest fixes from stable queue, if needed

  # http://git.kernel.org/?p=linux/kernel/git/stable/stable-queue.git


  # set DEFAULT_CONSOLE_LOGLEVEL to 4 (same value as the 'quiet' kernel param)

  # remove this when a Kconfig knob is made available by upstream

  # (relevant patch sent upstream: https://lkml.org/lkml/2011/7/26/227)

  patch -p1 -i "${srcdir}/change-default-console-loglevel.patch"

  # Fix System freeze with Wacom Bamboo One Tablet

  # Relevant patch: https://bugzilla.redhat.com/show_bug.cgi?id=1317116#c11

  patch -p1 -i "${srcdir}/fix-Bamboo-ONE-oops.patch"

  if [ "${CARCH}" = "x86_64" ]; then
    cat "${srcdir}/config.x86_64" > ./.config
  else
    cat "${srcdir}/config" > ./.config
  fi

  if [ "${_kernelname}" != "" ]; then
    sed -i "s|CONFIG_LOCALVERSION=.*|CONFIG_LOCALVERSION=\"${_kernelname}\"|g" ./.config
    sed -i "s|CONFIG_LOCALVERSION_AUTO=.*|CONFIG_LOCALVERSION_AUTO=n|" ./.config
  fi

  # set extraversion to pkgrel

  sed -ri "s|^(EXTRAVERSION =).*|\1 -${pkgrel}|" Makefile

  # don't run depmod on 'make install'. We'll do this ourselves in packaging

  sed -i '2iexit 0' scripts/depmod.sh

  # get kernel version

  make prepare

  # load configuration

  # Configure the kernel. Replace the line below with one of your choice.

  #make menuconfig # CLI menu for configuration

  #make nconfig # new CLI menu for configuration

  #make xconfig # X-based configuration

  #make oldconfig # using old config from previous kernel version

  # ... or manually edit .config


  # rewrite configuration

  yes "" | make config >/dev/null
}

MAKEFLAGS="-j8" makepkg

sudo pacman -U linux-Kafuu-4.5.1-1-x86_64.pkg.tar.xz linux-Kafuu-docs-4.5.1-1-x86_64.pkg.tar.xz linux-Kafuu-headers-4.5.1-1-x86_64.pkg.tar.xz

sudo grub-mkconfig

<input
  type="file"
  multiple
  accept="image/*"
  onchange={handleFile}
/>

function handleFile() {
  function extractDataAndDoSomething(f) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    const img = new Image();
    const fr = new FileReader();
    img.onload = () => {
      canvas.setAttribute('width', img.width);
      canvas.setAttribute('height', img.height);
      ctx.drawImage(img, 0, 0);

      // store loaded image.

      storeMyImage(canvas);
    };
    fr.onload = () => { img.src = fr.result; };
    fr.readAsDataURL(f);
  }
  for (const eachFile of new Array(...this.refs.fileInput.files)) {
    extractDataAndDoSomething(eachFile);
  }
}

function getAllPositions(width, height) {
  return function* pos() {
    for (let y = 0; y < height; ++y) {
      for (let x = 0; x < width; ++x) {
        yield [x, y, y * width * 4 + x * 4];
      }
    }
  };
}

const allPos = getAllpositions(imageData.width, imageData.height);
for (const [x, y, index] of allPos()) {
   imageData.data[index];     // Red

   imageData.data[index + 1]; // Green

   imageData.data[index + 2]; // Blue

   imageData.data[index + 3]; // Alpha

}

self.postMessage({
  width: image.width,
  height: image.height,
  buffer: image.data.buffer,
},[image.data.buffer]);

function onMessage({data}) {
  const imgd = new ImageData(
    new Uint8ClampedArray(data.image.buffer),
    data.image.width,
    data.image.height
  );

  // do somthing with recived imageData~

}

this.setState({
  honoka: {
    ...this.state.honoka,
    x: 2,
  },
})

function handleExportImage() {
  const a = document.createElement('a');
  a.setAttribute('download', 'proceed.png');
  a.setAttribute('href', canvas.toDataURL());
  a.setAttribute('style', 'position: fixed; width: 0; height: 0;');

  const link = document.body.appendChild(a);
  link.click();
  document.body.removeChild(link);
}

*** Error in `/usr/bin/mysql-workbench-bin': double free or corruption (out): 0x00000000011a5f00 ***

rm ~/.mysql/workbench/wb_options.xml

.
├── build                  // ES6 代码编译输出目录
├── .codeclimate.yml       // Code Climate 配置
├── config.js              // 程序自己的配置
├── coverage               // Istanbul 生成的测试报告目录
├── .eslintrc              // ESLint 配置
├── .git                   // git 目录
├── gulpfile.js            // Gulp 配置
├── mongodb.conf           // MongoDB 配置
├── node_modules           // NPM 安装的依赖模块目录
├── package.json           // 程序自己的 NPM 包信息
├── data                   // MongoDB 数据库目录
│   └── mongodb           
├── src                    // 源代码目录
│   └── app.js            
├── test                   // 测试程序目录
│   └── spec              
│       └── yahaloSpec.js
└── .travis.yml            // Travis CI 配置

npm init

"scripts": {
    "test": "gulp",
    "dev": "gulp dev",
    "run": "gulp run"
}

var appSrc = 'src/**/*.js'; // 程序源代码

var appDest = 'build/**/*.js'; // 编译输出的文件

var appDestPath = 'build'; // 编译输出目录

var testSrc = ['test/spec/*Spec.js']; // 测试程序源代码

var server = null; // 用来保存 http 服务器实例，在启动服务器测试的时候

var gulp = require('gulp');
var eslint = require('gulp-eslint');

gulp.task('lint', function() {
  return gulp.src(appSrc)
    .pipe(eslint({ rulePaths: ['./'] }))
    .pipe(eslint.format());
});

var babel  = require('gulp-babel');
var newer = require('gulp-newer');

gulp.task('compile', function() {
  return gulp.src(appSrc)
    .pipe(newer(appDestPath))
    .pipe(babel({ modules: 'common' }))
    .pipe(gulp.dest(appDestPath));
});

gulp.task('serve', function(callback) {
  server = require('./build/app');
  callback();
});

gulp.task('end-serve', function(callback) {
  if (server) {
    server.close();
    server = null;
  }
  callback();
});

var jasmine = require('gulp-jasmine');
var SpecReporter = require('jasmine-spec-reporter');
var istanbul = require('gulp-istanbul');

gulp.task('pre-test', function() {
  return gulp.src(appDest)
    .pipe(istanbul())
    .pipe(istanbul.hookRequire());
});

gulp.task('test', function() {
  return gulp.src(testSrc)
    .pipe(jasmine({ reporter: new SpecReporter() }))
    .on('end', function() {
      // 测试跑完关闭服务器

      server.close();
      server = null;
    })
    .pipe(istanbul.writeReports());
});

var runSequence = require('run-sequence');
gulp.task('watcher-appSrc', function(callback) {
  runSequence(
    'end-serve',
    'compile',
    'pre-test',
    'serve',
    'test',
    callback
  );
});

gulp.task('watcher-testSrc', function(callback) {
  runSequence(
    'pre-test',
    'test',
    callback
  );
});

gulp.task('watch', function(callback) {
  gulp.watch(appSrc, ['watcher-appSrc']);
  gulp.watch(testSrc, ['watcher-testSrc']);
  callback();
});

// once

gulp.task('default', function(callback) {
  runSequence(
    ['compile', 'lint'],
    'pre-test',
    'serve',
    'test',
    'end-serve',
    callback
  );});

// develop

gulp.task('dev', function(callback) {
  runSequence(
    'compile',
    'pre-test',
    'serve',
    'test',
    'watch',
    callback
  );
});

// run server

gulp.task('run', function(callback) {
  runSequence(
    'compile',
    'serve',
    callback
  );
});

npm install --save express gulp mongodb mongoskin run-sequence
npm install --save-dev babel-eslint gulp-babel gulp-eslint gulp-istanbul gulp-jasmine jasmine-spec-reporter hippie gulp-newer

var config = {
  serverPort: 2333, // 服务器端口

  databaseURI: 'mongodb://localhost:27017', // MongoDB 数据库 URI

  dev: true, // 开发模式标志

};

module.exports = config;

var hippie = require('hippie');
var port = require('../../config').serverPort;

describe('yahalo Spec !', function() {
  it('should get 200 yooo', function(done) {
    hippie()
      .base('http://localhost:' + port)
      .get('/')
      .expectStatus(200)
      .expectBody('yahalo! GET!')
      .end(function(err, res, body) {
        if (err) done.fail(err);
        else done();
      });
  });
});

# See http://www.mongodb.org/display/DOCS/File+Based+Configuration for format details
# Run mongod --help to see a list of options

port = 27017
bind_ip = 127.0.0.1
httpinterface = true
rest = true
quiet = false
dbpath = data/mongodb
logpath = data/mongod.log
logappend = true

import express from 'express';
import mongoose from 'mongoose';
import config from '../config';

const app = express();

mongoose.connect(config.databaseURI, () => {
  if (config.dev) {
    // 在开发模式运行的时候，在一开始清空数据库

    mongoose.connection.db.dropDatabase();
  }
});

app.get('/', (req, res) => {
  res.send('yahalo! GET!');
});

const server = app.listen(config.serverPort, () => {
  console.log(`my app listening at http://localhost:${server.address().port}`);

});

server.on('close', () => {
  // 在关闭服务器的时候断开数据库连接

  mongoose.connection.close();
});

export default server;

# 启用 eslint

eslint:

  enabled: true


# 设定要进行评级的代码

ratings:

  paths:

  - src/**/*.js

addons:

    code_climate:

        repo_token: balabalabalashaaa

# 指定程序语言

language: node_js


# 指定 node 版本，“node” 为最新的稳定版本

node_js:

  - "node"


# 启用 MongoDB

services:

  - mongodb


# 跑之前先安装依赖

install:

  - npm install codeclimate-test-reporter

  - npm install


# 执行 gulp 直接开跑

script: gulp


# 跑完报告测试覆盖率

after_script:

  - codeclimate-test-reporter < coverage/lcov.info

adb devices

adb reboot-bootloader

sudo fastboot devices

sudo fastboot oem unlock <设备解锁码>

sudo fastboot flash recovery <从 xda 下载下来的 TWRP 镜像文件目录>

sudo fastboot reboot

adb reboot recovery

PasswordAuthentication yes

PermitRootLogin yes

PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

#systemctl daemon-reload

#systemctl restart sshd.service