# git clone git://android.kernel.org/kernel/common.git kernel-goldfish
# cd kernel-goldfish
# git branch -r
  origin/HEAD
  origin/android-2.6.25
  origin/android-2.6.27
  origin/android-2.6.29
  origin/android-goldfish-2.6.27
  origin/android-goldfish-2.6.29

# git checkout --track -b android-goldfish-2.6.29 origin/android-goldfish-2.6.29

# export ARCH=arm
# export CROSS_COMPILE=/home/qt/android.blee/prebuilt/linux-x86/toolchain/arm-eabi-4.3.1/bin/arm-eabi-
# make goldfish_defconfig
# make

파일 복사
arch/arm/boot/zImage -> platforms/android-1.5/images/kernel-qemu

'안드로이드 > 플랫폼' 카테고리의 다른 글

ADB 사용  (0) 2009.10.18
SystemServer, MediaServer  (0) 2009.10.12
결과물  (0) 2009.09.30
service_manager 흐름  (0) 2009.08.25
init 분석 open 하는 디바이스 - null, kmsg  (0) 2009.08.18
Posted by blee
,


cd C:\and\android-sdk-windows-1.5_r3\tools

* emulator 실행

emulator.exe -avd blee

* shell 를 보고 싶을때

adb shell

* 파일 복사 ( push 는 emulator 로 복사 )

adb push acp.exe /data/acp.exe

* 파일 복사 ( pull 는 emulator 에서 가져 오는것 )
adb pull /init.rc ttt

* shell 에서 insmod 를 입력하면 .. 아래와 같이 나온다.
# insmod
insmod
usage: insmod <module.o>
#


hardware/libhardware/modules/README.android

# cd /system/lib/hw/
# ls -l
-rw-r--r-- root     root         9812 2009-07-01 00:24 sensors.goldfish.so
-rw-r--r-- root     root         5292 2009-07-01 00:26 lights.goldfish.so

'안드로이드 > 플랫폼' 카테고리의 다른 글

Goldfish-emulator용 커널 빌드  (0) 2009.10.20
SystemServer, MediaServer  (0) 2009.10.12
결과물  (0) 2009.09.30
service_manager 흐름  (0) 2009.08.25
init 분석 open 하는 디바이스 - null, kmsg  (0) 2009.08.18
Posted by blee
,

소스 분석중 system_server 와 mediaserver 의 코드는 동일한 동작을 보이고 있습니다.
그래서 저번 스터디시에 혼동이 있었는데요. 훓어 보니 동일한 동작이 아니였습니다.

타겟의 ps 로 보면, mediaserver 가 system_server 보다 빨리 시작되었다는 것을 알 수 있는데, 저희는 zygote 를 따라 가다 보니 system_server 를 먼저 분석하게 되었지요.
우선 이번주 스터디를 위해서 각각의 역할을 클리어 하게 정의 되어야 할 것 같다.

프로세스의 상태를 보면 아래와 같습니다.

root     1     0     280   192   c00bd90c 0000c8dc S /init
 :
root     1783  1     69252 19788 c00bd90c afe0c584 S zygote
media    1784  1     16232 3620  ffffffff afe0c45c S /system/bin/mediaserver
system   1807  1783  185064 26652 ffffffff afe0c45c S system_server

mediaserver 는 init 에 의해서 생성 되었고,
system_server 는 zygote 에 의해서 생성 되었다.

코드를 분석하면, 먼저 system_server 를 저번 주에 보았습니다.
자세히 보면, system_server 는 SurfaceFlinger::instantiate(); 만 실행하도록 되어 있습니다. proc->supportsProcesses() 는 true 를 리턴하도록 되어 있기 때문이지요.

이로서 저번 시간에 왜 동일한 동작을 할까에 대한 부분은 해결 되었습니다.
proc->supportsProcesses() 를 false 로 되는 환경이 있나 봅니다.

// frameworks/base/cmds/system_server/library/system_init.cpp
 :
    if (strcmp(propBuf, "1") == 0) {
        // Start the SurfaceFlinger
        SurfaceFlinger::instantiate();
    }

    // On the simulator, audioflinger et al don't get started the
    // same way as on the device, and we need to start them here
    if (!proc->supportsProcesses()) {

        // Start the AudioFlinger
        AudioFlinger::instantiate();

        // Start the media playback service
        MediaPlayerService::instantiate();

        // Start the camera service
        CameraService::instantiate();
    }
 :
 
실제로 mediaserver 에서 아래 서비스 provider 들이 시작 될 것입니다.

AudioFlinger::instantiate();
MediaPlayerService::instantiate();
CameraService::instantiate();

// frameworks/base/media/mediaserver/main_mediaserver.cpp 
int main(int argc, char** argv)
{
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();
    LOGI("ServiceManager: %p", sm.get());
    AudioFlinger::instantiate();
    MediaPlayerService::instantiate();
    CameraService::instantiate();
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

'안드로이드 > 플랫폼' 카테고리의 다른 글

Goldfish-emulator용 커널 빌드  (0) 2009.10.20
ADB 사용  (0) 2009.10.18
결과물  (0) 2009.09.30
service_manager 흐름  (0) 2009.08.25
init 분석 open 하는 디바이스 - null, kmsg  (0) 2009.08.18
Posted by blee
,
안드로이드 스터디모임에서 첫 결과물이 나왔습니다.

init 프로세스 정리 문서 :

* 스프링노트 사라짐.

IAMROOT 에서 세미나:


세미나(0.2)20101118.pdf





'안드로이드 > 플랫폼' 카테고리의 다른 글

ADB 사용  (0) 2009.10.18
SystemServer, MediaServer  (0) 2009.10.12
service_manager 흐름  (0) 2009.08.25
init 분석 open 하는 디바이스 - null, kmsg  (0) 2009.08.18
init 분석 - 메인루프의 poll 의 timeout  (0) 2009.07.28
Posted by blee
,
service manager 의 binder_parse 에서 처리하는 cmd 는 BR_NOOP, BR_TRANSACTION, BR_TRANSACTION_COMPLETE 입니다.

BR_NOOP, BR_TRANSACTION 는 항상 같이 붙어서 옵니다. 만찮가지로 BR_NOOP, BR_TRANSACTION_COMPLETE 는 항상 같이 붙어서 옵니다.

수신한 데이타의 포인터 처리는 mmap 의 영역내에 존재하고, 송신 하기 위한 데이타의 포인터 처리는 user 의 영역에 존재 합니다. ( binder 내부에서 사용자 영역을 mmap 영역으로 복사가 이루어 질 것이라고 예상합니다. )

다음은 로그를 찍어 가며 분석한 메모리 공간에서 포인터 처리와 서비스 핸들러 ( svcmgr_handler ) 에서 처리 하는 cmd 인 SVC_MGR_ADD_SERVICE, SVC_MGR_CHECK_SERVICE 에 대한 내용입니다.

binder_io 구조체가 두개 있는데, msg , reply 입니다. msg 는 수신한 데이타를 읽기 위한 포인터 조작에 사용되며, reply 는 송신할 데이타를 쓰기 위한포인터 조작에 사용됩니다. data, off 는 각각 읽거나 쓰면서 변경 되고,
data0, off0 는 초기 설정 값을 유지 합니다.

'안드로이드 > 플랫폼' 카테고리의 다른 글

SystemServer, MediaServer  (0) 2009.10.12
결과물  (0) 2009.09.30
init 분석 open 하는 디바이스 - null, kmsg  (0) 2009.08.18
init 분석 - 메인루프의 poll 의 timeout  (0) 2009.07.28
init 분석 - firmware  (0) 2009.07.28
Posted by blee
,

void open_devnull_stdio(void) 함수에서 "/dev/__null__" 이름의 노드를 만들어서 open 후 곧 삭제 합니다.

static const char *name = "/dev/__null__";
if (mknod(name, S_IFCHR | 0600, (1 << 8) | 3) == 0) {
:


void log_init(void) 함수에서 "/dev/__kmsg__" 이름의 노드를 만들어서 open 후 곧 삭제 합니다.

static const char *name = "/dev/__kmsg__";
if (mknod(name, S_IFCHR | 0600, (1 << 8) | 11) == 0) {
:

노드는 open 후 모두 삭제 하고, __null__ 를 stdin, stdout, stderr 로 지정 합니다.
__kmsg__ 는 로그를 남기기 위해서 open 하며, __kmsg__ 는 내부적으로 printk 함수를 사용해서 로그를 남깁니다.

커널 소스 kernel/drivers/char/mem.c 에서 정의된 memory device 목록 메이져 번호는 모두 1 번입니다.

static const struct {
    unsigned int        minor;
    char            *name;
    umode_t         mode;
    const struct file_operations    *fops;
} devlist[] = { /* list of minor devices */
#ifdef CONFIG_DEVMEM
    {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
#endif
#ifdef CONFIG_DEVKMEM
    {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
#endif
    {3, "null",    S_IRUGO | S_IWUGO,           &null_fops},
#ifdef CONFIG_DEVPORT
    {4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
#endif
    {5, "zero",    S_IRUGO | S_IWUGO,           &zero_fops},
    {7, "full",    S_IRUGO | S_IWUGO,           &full_fops},
    {8, "random",  S_IRUGO | S_IWUSR,           &random_fops},
    {9, "urandom", S_IRUGO | S_IWUSR,           &urandom_fops},
    {11,"kmsg",    S_IRUGO | S_IWUSR,           &kmsg_fops},
#ifdef CONFIG_CRASH_DUMP
    {12,"oldmem",    S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops},
#endif
};

'안드로이드 > 플랫폼' 카테고리의 다른 글

결과물  (0) 2009.09.30
service_manager 흐름  (0) 2009.08.25
init 분석 - 메인루프의 poll 의 timeout  (0) 2009.07.28
init 분석 - firmware  (0) 2009.07.28
init 분석 - 안드로이드 보안 및 권한  (0) 2009.07.28
Posted by blee
,

poll 에서 사용하는 timeout 변수의 계산은 재 시작해야 하는 서비스의 시작 시간을 맞추기 위해서 입니다. 재 시작 할 서비스는 이전에 시작 한 시간에서 5 초 후에 재 시작을 해주는 룰을 적용하고 있습니다.

서비스가 시작되면 time_started 에 시작 시간을 지정합니다.
서비스의 시작은 service_start 함수에서 처리하며, 이 함수의 마지막 단계에서 서비스의 시작 시간을 gettime() 으로 지정합니다.
( gettime() 은 초 단위로 리턴합니다. )

svc->time_started = gettime();

다음은 init 의 메인 루프 코드 입니다.
여기서 중요한 것들은 restart_processes, process_needs_restart, timeout , wait_for_one_process 의 관계입니다.

 

for(;;) {
    :
        restart_processes();

        if (process_needs_restart) {
            timeout = (process_needs_restart - gettime()) * 1000;
            if (timeout < 0)
                timeout = 0;
        }

        nr = poll(ufds, fd_count, timeout);
        if (nr <= 0)
            continue;

        if (ufds[2].revents == POLLIN) {
            /* we got a SIGCHLD - reap and restart as needed */
            read(signal_recv_fd, tmp, sizeof(tmp));
            while (!wait_for_one_process(0))
                ;
            continue;
        }
     :
    }

서비스가 종료 되어, SIGCHLD 시그널을 받으면( 여러 논의가 있었지만 여기서는 이것만 주목 하겠습니다.)
wait_for_one_process 함수를 호출 합니다.
wait_for_one_process 에서 주목 할 점은 해당 서비스의 flags 에 SVC_RESTARTING 속성을 더합니다.
실제로 재 시작 시키지는 않습니다.

svc->flags |= SVC_RESTARTING;

이후 init 의 for 루프를 다시 돌아서 restart_processes 를 호출 합니다.

static void restart_processes()
{
    process_needs_restart = 0;
    service_for_each_flags(SVC_RESTARTING,
                           restart_service_if_needed);
}

restart_processes 함수에서 process_needs_restart 변수를 0 으로 초기화 하고,
서비스 리스트 중에서 flags 에 SVC_RESTARTING 속성이 있는 것에 한해서 restart_service_if_needed 함수를 호출 합니다.
여기서 주목할 점은 링크드 리스트를 돈다는 것입니다. process_needs_restart 를 restart_service_if_needed 함수 내에서 설정 또는 변경 하는데, 모든 리스트가 다 돌고 난 후에 그 process_needs_restart 값이 init 에서 사용 됩니다.

 

static void restart_service_if_needed(struct service *svc)
{
    time_t next_start_time = svc->time_started + 5;

    if (next_start_time <= gettime()) {
        svc->flags &= (~SVC_RESTARTING);
        service_start(svc);
        return;
    }

    if ((next_start_time < process_needs_restart) ||
        (process_needs_restart == 0)) {
        process_needs_restart = next_start_time;
    }
}

restart_service_if_needed 함수에서는 svc->time_started 변수를 참조하는데, 이는 위에서도 설명 했듯이
서비스의 시작 시간 이였습니다. next_start_time 변수는 서비스가 이전에 시작 되었던 시간에서 5초를 더한 시간입니다.

결국 서비스가 재 시작 되어야 할 시간입니다. 서비스가 재 시작되어야 할 시간이 지났으면, service_start 함수를 호출해서 해당 서비스를 시작 시킴니다.
아직 재 시작 시킬 시간이 안되었다면, process_needs_restart 를 갱신하게 됩니다.

process_needs_restart 값이 초기값(0)이면, 지금 서비스의 재 시작 시간으로 갱신 되지만,
이 서비스 보다 링크드 리스트의 이전에 있던 서비스에 의해 갱신된 process_needs_restart 값을 가질 수도  있습니다.
그래서 지금 서비스의 재 시작 시간이 이전 서비스의 재 시작 시간보다 작으면, 지금 서비스의 재 시작 시간으로 process_needs_restart 를 갱신합니다.


결국 재시작 하려고 하는 서비스 중 가장 먼저 재 시작 되어야 할 시간으로 process_needs_restart 가 갱신 됩니다.

다시 init 으로 돌아 와서

      if (process_needs_restart) {
            timeout = (process_needs_restart - gettime()) * 1000;
            if (timeout < 0)
                timeout = 0;
        }

 

timeout 값은 재 시작 되어야 할 서비스들 중에서 가장 먼저 재 시작 할 서비스의 재 시작 시간 만큼을 위한 대기 시간이 지정됩니다.

그리고 그 값을 poll 의 timeout 으로 지정합니다. poll 의 timeout 발생후 다시 restart_processes 함수를 호출 하게 됩니다.

'안드로이드 > 플랫폼' 카테고리의 다른 글

service_manager 흐름  (0) 2009.08.25
init 분석 open 하는 디바이스 - null, kmsg  (0) 2009.08.18
init 분석 - firmware  (0) 2009.07.28
init 분석 - 안드로이드 보안 및 권한  (0) 2009.07.28
프로세스, 기본 환경  (0) 2009.07.28
Posted by blee
,

오늘날 리눅스 커널에서 firmware를 사용하는 가장 광범위한 방법은 header file 에 static 하게 link 하는 것입니다.
이는 정책적으로 기술적으로 다음과 같은 이슈가 있습니다.

1. 드라이버의 firmware 는 업그레이드 되어 재배포 될 수 있습니다.
2. 비록 단 한번의 사용 일지라도 static 하게 link 된 firmware 는 영구히 메모리를 차지 합니다.
3. 사용자들은 firmware 를 메모리에서 해제하고, 드라이버를 제거하는 것에 대해 신경쓰지 않습니다.

그러한 이유로 request_firmware() 와 hotplug 간의 interface 나오게 된 것입니다.

다음의 리눅스에서 driver 와 hotplug 간의 일련의 절차 입니다.

kernel 에서 처리 : 
driver 초기화 시에 request_firmware 함수를 호출합니다.

  if(request_firmware(&fw_entry, $FIRMWARE, device) == 0)
  copy_fw_to_device(fw_entry->data, fw_entry->size);
 release(fw_entry);

$FIRMWARE 는 파일 이름입니다. 이는 제조사에서 배포되는 특정 hw가 동작 되도록 하는 code image 일 것입니다.
request_firmware -> _request_firmware -> fw_setup_device 함수를 거치면서,
/sys/class/firmware/xxx/loading, /sys/class/firmware/xxx/data 파일을 생성합니다.
 
( hotplug 를 호출 하기 전에 firmware 를 __start_builtin_fw ~ __end_builtin_fw 영역에서 먼저 찾습니다.
이는 kernel 에 static 하게 포함된 firmware 들 중에 맞는 것이 있는지 먼저 검색합니다. 이 영역에 있다면
hotplug 관련 절차를 거치지 않습니다. )
 
그리고 사용자 공간의 hotplug 가 호출 됩니다.
request_firmware 함수는 block 됩니다.

( /sys/class/firmware/timeout 에 지정된 시간 만큼 입니다. )

사용자 공간 - hotplug 에서 처리 :

사용자 영역에서 /sys/class/firmware/xxx/loading, /sys/class/firmware/xxx/data 파일이 나타나며,
 $DEVPATH, $FIRMWARE 는 환경변수로 전달 됩니다.

 HOTPLUG_FW_DIR=/usr/lib/hotplug/firmware/

 echo 1 > /sys/$DEVPATH/loading
 cat $HOTPLUG_FW_DIR/$FIRMWARE > /sysfs/$DEVPATH/data
 echo 0 > /sys/$DEVPATH/loading

 /sys/$DEVPATH/loading 에 1 를 write 하므로써, firmware 복사가 시작됨을 알립니다.
펌웨어 파일 $HOTPLUG_FW_DIR/$FIRMWARE 를 /sysfs/$DEVPATH/data 로 복사를 합니다.
/sys/$DEVPATH/loading 에 0 를 write 하므로써, firmware 복사가 완료됨을 알립니다. request_firmware 함수는 성공을 리턴합니다.
/sys/$DEVPATH/loading 에 -1 를 write 하면, 중지되며, request_firmware 함수는 실패를 리턴합니다.
 
kernel 에서 처리 :
request_firmware() 함수가 return 되면, fw_entry->data, fw_entry->size 에 firmware와 size 정보가 저장됩니다.
이를 driver 에서 특정 hw 에 맞는 작업을 수행하면 됩니다.

사용자 공간으로 전달되는 환경변수 :

SUBSYSTEM=module
DEVPATH=/module/firmware_sample_driver
LD_LIBRARY_PATH=:/user/app/lib
PATH=/sbin:/bin:/usr/sbin:/usr/bin:/user/app/bin
ACTION=add
PWD=/
SHLVL=1
HOME=/
SEQNUM=933
_=/usr/bin/env

정리 :
안드로이드 플래폼의 init 에서 uevent 를 이용하여, add 절차를 거치면서, firmware 를 필요로 하는 driver에서
firmware 를 전달 하는 과정(hotplug 와 driver 사이의 일어나는 일련의 절차)를 처리 해주고 있는 것입니다.

static int load_firmware(int fw_fd, int loading_fd, int data_fd)
{
    struct stat st;
    long len_to_copy;
    int ret = 0;

    if(fstat(fw_fd, &st) < 0)                     <--(주석) fstat는 열린 파일이나 핸들과 연관된 디렉토리의 정보를 stat 구조체에 저장
        return -1;
    len_to_copy = st.st_size;

//------------------------------------------------------------ 
//! echo 1 > /sys/$DEVPATH/loading
//------------------------------------------------------------ 
    write(loading_fd, "1", 1);  /* start transfer */

//------------------------------------------------------------ 
//! cat $HOTPLUG_FW_DIR/$FIRMWARE > /sysfs/$DEVPATH/data
//------------------------------------------------------------ 
    while (len_to_copy > 0) {
        char buf[PAGE_SIZE];
        ssize_t nr;

        nr = read(fw_fd, buf, sizeof(buf));    
        if(!nr)
            break;
        if(nr < 0) {
            ret = -1;
            break;
        }

        len_to_copy -= nr;
        while (nr > 0) {
            ssize_t nw = 0;

            nw = write(data_fd, buf + nw, nr); 
            if(nw <= 0) {
                ret = -1;
                goto out;
            }
            nr -= nw;
        }
    }

//------------------------------------------------------------ 
// echo 0 > /sys/$DEVPATH/loading 
//------------------------------------------------------------ 
out:
    if(!ret)
        write(loading_fd, "0", 1);  /* successful end of transfer */
    else
        write(loading_fd, "-1", 2); /* abort transfer */

    return ret;
}

참고 :  
kernel/Documentation/firmware_class/README
linux device driver model 관련 문서


Posted by blee
,

http://d.android.com/guide/topics/security/security.html

위 사이트는 안드로이드 security, permission 정책에 관한 문서 입니다.

문서의 서론만 옮겨 봤습니다.

Security and Permissions
Android is a multi-process system, in which each application (and parts of the system) runs in its own process. Most security between applications and the system is enforced at the process level through standard Linux facilities, such as user and group IDs that are assigned to applications. Additional finer-grained security features are provided through a "permission" mechanism that enforces restrictions on the specific operations that a particular process can perform, and per-URI permissions for granting ad-hoc access to specific pieces of data.
보안 및 권한
안드로이드는 멀티-프로세스 시스템이다, 시스템의 각 응용 프로그램은 자체 프로세스에서 실행됩니다. 응용 프로그램과 시스템 사이의 대부분의 보안은 프로세스 수준에서 애플리케이션에 할당된 사용자와 그룹 ID등으로 표준 리눅스 환경을 통해 시행됩니다. 추가적인 세밀한 보안 기능은 특정 프로세스 수행 할수 있는 구체적인 작업에 대한 제한을 적용하는 "permission" 메커니즘과 지정된 데이타에 ad-hoc 접권의 하가를 위한 per-URI 권한을 통해 제공되어 집니다.

이미 알고 있듯이 전통적인 linux 환경의 /etc/passwd 파일을 이용한 사용자 및 /etc/group 파일을 이용한 그룹 설정을 사용하지 않는 다는 것이 인상적입니다.

application 권한은 설치할때, 이러한 permission 이 결정되고, 이 후 변경하지 못 한다라고 하는데, 모든 안드로이드 어플리케이션은 AndroidManifest.xml 파일을 가지고 있으며, 이 파일을 통해서 권한 설정을 합니다. 그리고 안드로이드 어플리케이션은 인증서로 서명을 해야 합니다. 이 부분은 프로그램을 직접 만들어 봐야 겠네요 -_-;

안드로이드 어플리케이션에 대한 분석이라는 글에서 AndroidManifest.xml 파일에 대한 언급이 있어서 링크 합니다.  http://breathair.tistory.com/70

그렇다면, 안드로이드는 어떠한 사용자와 그룹으로 관리하는가? 이에 대한 인터넷 자료를 구할 수가 없었습니다. 그래서 직접 소스를 올렸습니다.

android_filesystem_config.h 파일에 USER ID, GROUP ID 가 정의 되어 있습니다.
( 소스경로 : system/core/include/private/android_filesystem_config.h )

android_dirs, android_files 의 배열은 mkrootfs 와 mkyaffs2image 툴로 루트 파일 시스템을 만들 때 적용된다고 주석에 나와 있습니다.
( mkbootfs 소스경로 : system/core/cpio/mkbootfs.c )

devices.c 에 정의된 devperms 배열은 init 에서 uevent 처리 하며, /dev/ 이하 파일을 만들어 줍니다.
( 소스경로 : system/core/init/devices.c )

USER ID와 GROUP ID 를 아래와 같이 분류해논 이유를 찾을려고 했는데, 잘 못 찾겠네요. -_-;

//---------------------------------------------------------------------------
// system/core/include/private/android_filesystem_config.h
//---------------------------------------------------------------------------
/* This is the master Users and Groups config for the platform.
** DO NOT EVER RENUMBER.
*/

#define AID_ROOT             0  /* traditional unix root user */
#define AID_SYSTEM        1000  /* system server */
#define AID_RADIO         1001  /* telephony subsystem, RIL */
#define AID_BLUETOOTH     1002  /* bluetooth subsystem */
#define AID_GRAPHICS      1003  /* graphics devices */
#define AID_INPUT         1004  /* input devices */
#define AID_AUDIO         1005  /* audio devices */
#define AID_CAMERA        1006  /* camera devices */
#define AID_LOG           1007  /* log devices */
#define AID_COMPASS       1008  /* compass device */
#define AID_MOUNT         1009  /* mountd socket */
#define AID_WIFI          1010  /* wifi subsystem */
#define AID_ADB           1011  /* android debug bridge (adbd) */
#define AID_INSTALL       1012  /* group for installing packages */
#define AID_MEDIA         1013  /* mediaserver process */
#define AID_DHCP          1014  /* dhcp client */
#define AID_SHELL         2000  /* adb and debug shell user */
#define AID_CACHE         2001  /* cache access */
#define AID_DIAG          2002  /* access to diagnostic resources */

/* The 3000 series are intended for use as supplemental group id's only.
 * They indicate special Android capabilities that the kernel is aware of. */
#define AID_NET_BT_ADMIN  3001  /* bluetooth: create any socket */
#define AID_NET_BT        3002  /* bluetooth: create sco, rfcomm or l2cap sockets */
#define AID_INET          3003  /* can create AF_INET and AF_INET6 sockets */
#define AID_NET_RAW       3004  /* can create raw INET sockets */
#define AID_MISC          9998  /* access to misc storage */
#define AID_NOBODY        9999
#define AID_APP          10000 /* first app user */

static struct android_id_info android_ids[] = {
    { "root",      AID_ROOT, },
    { "system",    AID_SYSTEM, },
    { "radio",     AID_RADIO, },
    { "bluetooth", AID_BLUETOOTH, },
    { "graphics",  AID_GRAPHICS, },
    { "input",     AID_INPUT, },
    { "audio",     AID_AUDIO, },
    { "camera",    AID_CAMERA, },
    { "log",       AID_LOG, },
    { "compass",   AID_COMPASS, },
    { "mount",     AID_MOUNT, },
    { "wifi",      AID_WIFI, },
    { "dhcp",      AID_DHCP, },
    { "adb",       AID_ADB, },
    { "install",   AID_INSTALL, },
    { "media",     AID_MEDIA, },
    { "shell",     AID_SHELL, },
    { "cache",     AID_CACHE, },
    { "diag",      AID_DIAG, },
    { "net_bt_admin", AID_NET_BT_ADMIN, },
    { "net_bt",    AID_NET_BT, },
    { "inet",      AID_INET, },
    { "net_raw",   AID_NET_RAW, },
    { "misc",      AID_MISC, },
    { "nobody",    AID_NOBODY, },
};

/* Rules for directories.
** These rules are applied based on "first match", so they
** should start with the most specific path and work their
** way up to the root.
*/

static struct fs_path_config android_dirs[] = {
    { 00770, AID_SYSTEM, AID_CACHE,  "cache" },
    { 00771, AID_SYSTEM, AID_SYSTEM, "data/app" },
    { 00771, AID_SYSTEM, AID_SYSTEM, "data/app-private" },
    { 00771, AID_SYSTEM, AID_SYSTEM, "data/dalvik-cache" },
    { 00771, AID_SYSTEM, AID_SYSTEM, "data/data" },
    { 00771, AID_SHELL,  AID_SHELL,  "data/local/tmp" },
    { 00771, AID_SHELL,  AID_SHELL,  "data/local" },
    { 01771, AID_SYSTEM, AID_MISC,   "data/misc" },
    { 00770, AID_DHCP,   AID_DHCP,   "data/misc/dhcp" },
    { 00771, AID_SYSTEM, AID_SYSTEM, "data" },
    { 00750, AID_ROOT,   AID_SHELL,  "sbin" },
    { 00755, AID_ROOT,   AID_SHELL,  "system/bin" },
    { 00755, AID_ROOT,   AID_SHELL,  "system/xbin" },
    { 00777, AID_ROOT,   AID_ROOT,   "system/etc/ppp" }, /* REMOVE */
    { 00777, AID_ROOT,   AID_ROOT,   "sdcard" },
    { 00755, AID_ROOT,   AID_ROOT,   0 },
};


/* Rules for files.
** These rules are applied based on "first match", so they
** should start with the most specific path and work their
** way up to the root. Prefixes ending in * denotes wildcard
** and will allow partial matches.
*/
static struct fs_path_config android_files[] = {
    { 00555, AID_ROOT,      AID_ROOT,      "system/etc/ppp/ip-up" },
    { 00555, AID_ROOT,      AID_ROOT,      "system/etc/ppp/ip-down" },
    { 00440, AID_ROOT,      AID_SHELL,     "system/etc/init.goldfish.rc" },
    { 00550, AID_ROOT,      AID_SHELL,     "system/etc/init.goldfish.sh" },
    { 00440, AID_ROOT,      AID_SHELL,     "system/etc/init.trout.rc" },
    { 00550, AID_ROOT,      AID_SHELL,     "system/etc/init.ril" },
    { 00550, AID_ROOT,      AID_SHELL,     "system/etc/init.testmenu" },
    { 00550, AID_ROOT,      AID_SHELL,     "system/etc/init.gprs-pppd" },
    { 00550, AID_DHCP,      AID_SHELL,     "system/etc/dhcpcd/dhcpcd-run-hooks" },
    { 00440, AID_BLUETOOTH, AID_BLUETOOTH, "system/etc/dbus.conf" },
    { 00440, AID_BLUETOOTH, AID_BLUETOOTH, "system/etc/bluez/hcid.conf" },
    { 00440, AID_BLUETOOTH, AID_BLUETOOTH, "system/etc/bluez/input.conf" },
    { 00440, AID_BLUETOOTH, AID_BLUETOOTH, "system/etc/bluez/audio.conf" },
    { 00440, AID_RADIO,     AID_AUDIO,     "/system/etc/AudioPara4.csv" },
    { 00644, AID_SYSTEM,    AID_SYSTEM,    "data/app/*" },
    { 00644, AID_SYSTEM,    AID_SYSTEM,    "data/app-private/*" },
    { 00644, AID_APP,       AID_APP,       "data/data/*" },
        /* the following two files are INTENTIONALLY set-gid and not set-uid.
         * Do not change. */
    { 02755, AID_ROOT,      AID_NET_RAW,   "system/bin/ping" },
    { 02755, AID_ROOT,      AID_INET,      "system/bin/netcfg" },
        /* the following four files are INTENTIONALLY set-uid, but they
     * are NOT included on user builds. */
    { 06755, AID_ROOT,      AID_ROOT,      "system/xbin/su" },
    { 06755, AID_ROOT,      AID_ROOT,      "system/xbin/librank" },
    { 06755, AID_ROOT,      AID_ROOT,      "system/xbin/procrank" },
    { 06755, AID_ROOT,      AID_ROOT,      "system/xbin/procmem" },
    { 00755, AID_ROOT,      AID_SHELL,     "system/bin/*" },
    { 00755, AID_ROOT,      AID_SHELL,     "system/xbin/*" },
    { 00750, AID_ROOT,      AID_SHELL,     "sbin/*" },
    { 00755, AID_ROOT,      AID_ROOT,      "bin/*" },
    { 00750, AID_ROOT,      AID_SHELL,     "init*" },
    { 00644, AID_ROOT,      AID_ROOT,       0 },
};

//---------------------------------------------------------------------------
// system/core/init/devices.c
//---------------------------------------------------------------------------

static struct perms_ devperms[] = {
    { "/dev/null",          0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/zero",          0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/full",          0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/ptmx",          0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/tty",           0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/random",        0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/urandom",       0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/ashmem",        0666,   AID_ROOT,       AID_ROOT,       0 },
    { "/dev/binder",        0666,   AID_ROOT,       AID_ROOT,       0 },

        /* logger should be world writable (for logging) but not readable */
    { "/dev/log/",          0662,   AID_ROOT,       AID_LOG,        1 },

        /* these should not be world writable */
    { "/dev/android_adb",   0660,   AID_ADB,        AID_ADB,        0 },
    { "/dev/android_adb_enable",   0660,   AID_ADB,        AID_ADB,        0 },
    { "/dev/ttyMSM0",       0600,   AID_BLUETOOTH,  AID_BLUETOOTH,  0 },
    { "/dev/ttyHS0",        0600,   AID_BLUETOOTH,  AID_BLUETOOTH,  0 },
    { "/dev/uinput",        0600,   AID_BLUETOOTH,  AID_BLUETOOTH,  0 },
    { "/dev/alarm",         0664,   AID_SYSTEM,     AID_RADIO,      0 },
    { "/dev/tty0",          0660,   AID_ROOT,       AID_SYSTEM,     0 },
    { "/dev/graphics/",     0660,   AID_ROOT,       AID_GRAPHICS,   1 },
    { "/dev/hw3d",          0660,   AID_SYSTEM,     AID_GRAPHICS,   0 },
    { "/dev/input/",        0660,   AID_ROOT,       AID_INPUT,      1 },
    { "/dev/eac",           0660,   AID_ROOT,       AID_AUDIO,      0 },
    { "/dev/cam",           0660,   AID_ROOT,       AID_CAMERA,     0 },
    { "/dev/pmem",          0660,   AID_SYSTEM,     AID_GRAPHICS,   0 },
    { "/dev/pmem_gpu",      0660,   AID_SYSTEM,     AID_GRAPHICS,   1 },
    { "/dev/pmem_adsp",     0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/pmem_camera",   0660,   AID_SYSTEM,     AID_CAMERA,     1 },
    { "/dev/oncrpc/",       0660,   AID_ROOT,       AID_SYSTEM,     1 },
    { "/dev/adsp/",         0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/mt9t013",       0660,   AID_SYSTEM,     AID_SYSTEM,     0 },
    { "/dev/akm8976_daemon",0640,   AID_COMPASS,    AID_SYSTEM,     0 },
    { "/dev/akm8976_aot",   0640,   AID_COMPASS,    AID_SYSTEM,     0 },
    { "/dev/akm8976_pffd",  0640,   AID_COMPASS,    AID_SYSTEM,     0 },
    { "/dev/msm_pcm_out",   0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/msm_pcm_in",    0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/msm_pcm_ctl",   0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/msm_snd",       0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/msm_mp3",       0660,   AID_SYSTEM,     AID_AUDIO,      1 },
    { "/dev/msm_audpre",    0660,   AID_SYSTEM,     AID_AUDIO,      0 },
    { "/dev/htc-acoustic",  0660,   AID_SYSTEM,     AID_AUDIO,      0 },
    { "/dev/smd0",          0640,   AID_RADIO,      AID_RADIO,      0 },
    { "/dev/qmi",           0640,   AID_RADIO,      AID_RADIO,      0 },
    { "/dev/qmi0",          0640,   AID_RADIO,      AID_RADIO,      0 },
    { "/dev/qmi1",          0640,   AID_RADIO,      AID_RADIO,      0 },
    { "/dev/qmi2",          0640,   AID_RADIO,      AID_RADIO,      0 },
    { NULL, 0, 0, 0, 0 },
};

'안드로이드 > 플랫폼' 카테고리의 다른 글

init 분석 - 메인루프의 poll 의 timeout  (0) 2009.07.28
init 분석 - firmware  (0) 2009.07.28
프로세스, 기본 환경  (0) 2009.07.28
안드로이드 부팅과정  (0) 2009.07.28
안드로이드 커널 빌드  (0) 2009.07.28
Posted by blee
,
# ps
USER   PID   PPID  VSIZE RSS   WCHAN    PC         NAME
root     1     0     280   192   c00bd90c 0000c8dc S /init
root     2     0     0     0     c005bd7c 00000000 S kthreadd
root     3     2     0     0     c004c6d4 00000000 S ksoftirqd/0
root     4     2     0     0     c0077b58 00000000 S watchdog/0
root     5     2     0     0     c00584f0 00000000 S events/0
root     6     2     0     0     c00584f0 00000000 S khelper
root     9     2     0     0     c00584f0 00000000 S netns
root     14    2     0     0     c00584f0 00000000 S suspend
root     151   2     0     0     c00584f0 00000000 S kblockd/0
root     157   2     0     0     c00584f0 00000000 S ksuspend_usbd
root     162   2     0     0     c022dc24 00000000 S khubd
root     165   2     0     0     c02424f0 00000000 S kseriod
root     189   2     0     0     c008f080 00000000 S pdflush
root     190   2     0     0     c008f080 00000000 S pdflush
root     191   2     0     0     c00938cc 00000000 S kswapd0
root     193   2     0     0     c00584f0 00000000 S aio/0
root     194   2     0     0     c00584f0 00000000 S nfsiod
root     902   2     0     0     c021d508 00000000 S mtdblockd
root     979   2     0     0     c00584f0 00000000 S rpciod/0
root     1777  1     740   328   c004a204 afe0d08c S /system/bin/sh
system   1778  1     808   264   c0257cec afe0c45c S /system/bin/servicemanager
root     1780  1     840   360   c00bd90c afe0c584 S /system/bin/vold
root     1781  1     668   264   c02678d4 afe0cdec S /system/bin/debuggerd
radio    1782  1     4372  684   ffffffff afe0cacc S /system/bin/rild
root     1783  1     69252 19788 c00bd90c afe0c584 S zygote
media    1784  1     16232 3620  ffffffff afe0c45c S /system/bin/mediaserver
bluetooth 1786  1     1168  568   c00bd90c afe0d25c S /system/bin/dbus-daemon
root     1788  1     804   304   c02c553c afe0c1bc S /system/bin/installd
root     1794  1     1268  124   ffffffff 0000e8f4 S /sbin/adbd
system   1807  1783  185064 26652 ffffffff afe0c45c S system_server
radio    1846  1783  109532 17840 ffffffff afe0d3e4 S com.android.phone
app_1    1852  1783  122476 24276 ffffffff afe0d3e4 S android.process.acore
app_11   1882  1783  91352 15736 ffffffff afe0d3e4 S com.android.mms
app_2    1907  1783  97336 17452 ffffffff afe0d3e4 S android.process.media
app_5    1919  1783  90088 15328 ffffffff afe0d3e4 S com.android.alarmclock
app_7    1928  1783  93640 16692 ffffffff afe0d3e4 S com.android.calendar
app_1    1945  1783  92116 15568 ffffffff afe0d3e4 S com.android.inputmethod.latin
root     1975  1777  892   340   00000000 afe0c1bc R ps
# ls -l
drwxrwxrwt root     root              1970-01-01 00:00 sqlite_stmt_journals
drwxrwx--- system   cache             1970-01-01 00:00 cache
drwxrwx--x system   system            2009-06-08 23:50 data
drwxr-xr-x root     root              2009-06-09 05:34 system
d--------- system   system            1970-01-01 00:00 sdcard
lrwxrwxrwx root     root              1970-01-01 00:00 etc -> /system/etc
drwxr-xr-x root     root              1970-01-01 00:00 sys
dr-xr-xr-x root     root              1970-01-01 00:00 proc
drwxr-xr-x root     root              1970-01-01 00:00 dev
-rwxr-xr-x root       root         106568 2009-07-02 08:07 init
drwxr-xr-x root     root              2009-06-09 05:34 sbin
-rw-r--r-- root       root           9270 2009-07-02 08:36 init.rc
-rw-r--r-- root       root           1682 2009-07-02 08:08 init.goldfish.rc
-rw-r--r-- root     root          118 2009-06-09 05:34 default.prop
drw-rw-rw- root     root              1970-01-01 00:00 lost+found

# mount
rootfs / rootfs rw 0 0
/dev/root / yaffs2 ro 0 0
tmpfs /dev tmpfs rw,mode=755 0 0
devpts /dev/pts devpts rw,mode=600,ptmxmode=000 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
tmpfs /sqlite_stmt_journals tmpfs rw,size=4096k 0 0
/dev/block/mtdblock5 /system yaffs2 ro 0 0
/dev/block/mtdblock6 /data yaffs2 rw,nosuid,nodev 0 0
/dev/block/mtdblock4 /cache yaffs2 rw,nosuid,nodev 0 0

# df
/: 4096K total, 1420K used, 2676K available (block size 4096)
/: 4096K total, 1420K used, 2676K available (block size 4096)
/dev: 100900K total, 0K used, 100900K available (block size 4096)
/sqlite_stmt_journals: 4096K total, 0K used, 4096K available (block size 4096)
/system: 51200K total, 45212K used, 5988K available (block size 4096)
/data: 457344K total, 18332K used, 439012K available (block size 4096)
/cache: 8192K total, 6344K used, 1848K available (block size 4096)

Posted by blee
,