Bug 1644

Summary: kernel: development workflow usecase documentation and support
Product: [Build System, Metadata & Runtime] Meta-yocto Reporter: Song Liu <song.liu>
Component: meta-yoctoAssignee: Bruce Ashfield <bruce.ashfield>
Status: RESOLVED FIXED QA Contact:
Severity: enhancement    
Priority: Low CC: bruce.ashfield, dvhart, jessica.zhang, poky.bs.watcher, poky.watcher, yi.zhao
Version: unspecified   
Target Milestone: 1.2 M4   
Hardware: x86   
OS: Multiple   
Whiteboard: (P1) (Test Plan Ready)- done for 1.2, see 2333 for remaining work
OS type for building Yocto: --- Type of Regression: ---
Verified: Documentation change: ---

Description Song Liu 2011-10-04 22:32:27 UTC
BSP config streamlining, building the kernel standalone, yoctoization, meta data sharing
Comment 1 Bruce Ashfield 2011-10-06 12:07:49 UTC
This covers the following items (And can be split as required):

Config streamlining:

  - Configuration fragment audit and refactoring for improved sharing
    and updating to a new kernel verison
  - Ability to pass a constructed .config to the kernel configuration 
    subysystem via other methods than defconfig processing. This is
    required to create truly small configs

Standalone builds:
  - Using in tree kernel tools to configure and build the kernel without
    any build system assistance (rapid build, boot, debug cycles).

Yoctoization:
  - Release and support the documented ability to create and manage
    meta data for any kernel repository

meta data sharing:
  - Support multiple meta branches/sources to allow multiple repositories
    to export and re-use meta data.
Comment 2 Bruce Ashfield 2011-11-04 19:27:45 UTC
The following are the updated kernel workflows/use cases that support:

  - BSP / driver development using the yocto kernel
  - BSP porting to the yocto kernel from 'vendor drops'
  - Using yocto as a test bed for kernel development (where 'kernel' can be any kernel)
  - Using yocto to enable debug options for feature development
  - Using yocto to perform automatic/regression testing via built in kernel tests.

Config streamlining:                                                                                                                             
                                                                                                                                                 
  - Configuration fragment audit and refactoring for improved sharing and                                                                        
    updating to a new kernel verison                                                                                                             
                                                                                                                                                 
  - Ability to pass a constructed .config to the kernel configuration                                                                            
    subysystem via other methods than defconfig processing. This is required                                                                     
    to create truly small configs                                                                                                                
                                                                                                                                                 
  - Configuration fragments that enable the maximum use of built in kernel                                                                       
    self tests for regression and smoke testing.                                                                                                 
                                                                                                                                                 
Standalone builds:                                                                                                                               
                                                                                                                                                 
  - Using in tree kernel tools to configure and build the kernel without any                                                                     
    build system assistance (rapid build, boot, debug cycles).                                                                                   
                                                                                                                                                 
Yoctoization:                                                                                                                                    
                                                                                                                                                 
  - Release and support the documented ability to create and manage meta data                                                                    
    for any kernel repository                                                                                                                    
                                                                                                                                                 
Meta data sharing:                                                                                                                               
                                                                                                                                                 
  - Support multiple meta branches/sources to allow multiple repositories to                                                                     
    export and re-use meta data.                                                                                                                 
                                                                                                                                                 
Streamlined builds:                                                                                                                              
                                                                                                                                                 
  - Documentation about how to trigger a build maximizing the use of prebuilt                                                                    
    images and packages.                                                                                                                         
                                                                                                                                                 
  - A meta layer that creates the smallest possible image for 'useful' kernel                                                                    
    debug and testing.                                                                                                                           
                                                                                                                                                 
  - Provide a workflow that allows a rapid cycle of modify, build and boot.                         

                           Development support:                                                                                                                             
                                                                                                                                                 
  - Provide facilities for building modules on the target                                                                                        
                                                                                                                                                 
  - Provide scripts and configuration fragments to enable debug                                                                                  
    options and for efficient setup of debug utilities.                                                                                          
                                                                                                                                                 
  - Provide the tools for efficient separation and import of                                                                                     
    changes into the yocto kernel repository.
Comment 3 Yi Zhao 2011-11-28 00:04:36 UTC
Hi Bruce,
QA will try to develop test case for this feature, but now we are not very clear what will be implemented for this feature. Would you please give us more details for it and what will be delivered in M1 ?

Thanks.
Comment 4 Bruce Ashfield 2011-11-28 04:32:19 UTC
The only deliverable for M1 was to be the standalone tree building
use case. But I'm travelling at the moment, so it may slip to very
early M2.

For this case, it simply means that if the kernel tools (creatme,
updatme,patchme,configme, etc) are provided as part of the kernel
tree itself, the recipes will use those tools instead of the kern-tools
packaged ones. That means that the tree can be completely manipulated
by cloning the repository and building, with no bitbake or other
build systems required.

The remaining use cases are largely documentation, and I'll update this
case as they progress in M2.
Comment 5 Bruce Ashfield 2012-03-19 18:19:09 UTC
This feature changed slightly as 1.2 progressed. The following is the final status:

Config streamlining:
-----------------------------
   Partially completed (will be tweaked through M4):
      - Configuration fragment audit and refactoring for improved sharing and
        updating to a new kernel version. 

   Completed
    - Ability to pass a constructed .config to the kernel configuration           
       subysystem via other methods than defconfig processing. This is required    
       to create truly small configs                                               
 
   Not completed (Moves to 1.3):
     - Configuration fragments that enable the maximum use of built in kernel      
       self tests for regression and smoke testing.                                


Standalone builds:                                                              
--------------------------
  completed (but not used by yocto):
    - Using in tree kernel tools to configure and build the kernel without any    
      build system assistance (rapid build, boot, debug cycles).                  

Yoctoization:                                                                   
--------------------
  completed:
     - Release and support the documented ability to create and manage meta data   
       for any kernel repository
     - The ability to build any repository with the yocto recipes / tools.
   
      ** this will be enhanced going forward


Meta data sharing:                                                              
---------------------------
  completed:
     - Support multiple meta branches/sources to allow multiple repositories to    
       export and re-use meta data. 

       ** implement via full out of tree feature specification

Streamlined builds:                                                             
-----------------------------
completed:
  - Documentation about how to trigger a build maximizing the use of prebuilt   
    images and packages.  (done outside of the kernel)
  - A meta layer that creates the smallest possible image for 'useful' kernel   
    debug and testing.  (meta kernel dev and poky-tiny) (** meta-kernel-dev still needs to move)           

partially completed:
  - Provide a workflow that allows a rapid cycle of modify, build and boot.

    ** external src, and other areas will be explored in 1.3.

 Development support:
--------------------------------
partially completed:
  - Provide the tools for efficient separation and import of
    changes into the yocto kernel repository. (simple git merges and out of tree features for 1.2)

not completed:
  - Provide facilities for building modules on the target
  - Provide scripts and configuration fragments to enable debug
    options and for efficient setup of debug utilities.
Comment 6 Darren Hart 2012-05-01 15:48:36 UTC
This bug needs to be broken up into individual tasks. We already have bugs for things like building modules on target. Can we just close this bug as the whiteboard referes to 2333?
Comment 7 Bruce Ashfield 2012-05-01 16:20:04 UTC
We can call this done. I have new use cases for 1.3 (with the tools updates,
and from what we've learned via Tom's tools, etc), so this can be closed.