MontaVista Linux Professional Edition Jump Start Training - PowerPoint PPT Presentation


PPT – MontaVista Linux Professional Edition Jump Start Training PowerPoint presentation | free to view - id: 126b68-YTkxN


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation

MontaVista Linux Professional Edition Jump Start Training


1. MontaVista Linux. Professional Edition. Jump Start Training. Embedded Linux ... Solaris ... Richard Stones and Neil Matthew , WROX Press, Ltd., 1-861002-97-1. ... – PowerPoint PPT presentation

Number of Views:586
Avg rating:3.0/5.0
Slides: 72
Provided by: insaCom


Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: MontaVista Linux Professional Edition Jump Start Training

MontaVista LinuxProfessional EditionJump Start
  • Embedded Linux Technology Inc.,
  • Taiwan Branch
  • Email
  • TEL 02-23784056

  • 1010 1100
  • Preparing Development System
  • Development Environment
  • Boot ROM
  • 1110 1200
  • Boot Configure and Download
  • MontaVista Development Tools (I)
  • 1310 1400
  • MontaVista Development Tools (II)
  • 1410 1500
  • File Systems
  • Kernel Modules
  • 1510 1600
  • MontaVista Realtime

Preparing Development System
  • MontaVista Software Package Installation
  • Supported Host Distributions
  • MVL PE 2.1 MVL PE 3.0
  • Mandrake 7.2, 8.0 and 8.1 8.1
  • RedHat 6.2, 7.0, 7.1 and 7.2 7.2 and 7.3
  • SuSE 7.3 7.3
  • Yellow Dog 2.1 2.1
  • Solaris 7 and 8 7 and 8
  • VMwaretm Workstation 3.1 on Windows(R)
    NT/2000/XP with a Red Hat 7.2 Host
  • Host Configuration
  • NFS, bootp, tftp, firewall, PATH,
  • PATH /opt/hardhat/devkit/host/bin
  • /opt/hardhat/devkit/arm/xscale_be/bin

Development Environment
Boot ROM
  • Possible Duties
  • Turn on various chip enables (so RAM exists)
  • Initialize I/O chips possibly including serial
    port to report Boot ROM success/fail and a
    network or disk device interface to boot the OS
  • Perform system self-test, report results
  • Provide an command line interface (CLI)
  • Receive S Records into RAM, and then burn that
    compressed data into Flash

Boot ROM
  • Contents
  • Board- and CPU architecture-specific
    initialization code
  • Ability to download the operating system image
    through one or more mechanisms
  • Transfer control to that software
  • May also assist in debugging the application
    system, and running system integrity tests

Boot ROM
  • Booting the Target System
  • Step 1 Press the target Reset button (if it has
    one) or apply power to the target
  • Boot ROM begins executing for the very first time
  • Step 1A Boot ROM looks to you for help.
  • Step 1B Configure Boot ROM according to how you
    want it to boot your test software. Tell Boot ROM
    to remember those settings.

Boot ROM
  • Booting the Target System (contd)
  • Step 2 Press target Reset or cycle the power
  • Boot ROM downloads your test software and jumps
    into it
  • Your test software is now running
  • Repeat Step 2 as needed

Boot ROM
  • Who, in general, creates Boot ROMs?
  • Who is responsible for the Boot ROM you will be
  • Redboot frequently used Xscale bootstrap
  • Developed by RedHat
  • How to get source and toolchain for Redboot
  • URL http//
  • Embedded Software Development with eCOS, A. J.
    Massa, Prentice Hall

Boot Config. Download
  • Assumptions for the Lab Equipment
  • Using BOOTP and TFTP to transfer the booting
    operating system from the host system disk to the
    target system memory
  • A portion of the hosts file system will be
    available to the target operating system by an
    NFS mount
  • The Steps
  • Step B - Build the target binary (vmlinux)
  • Step C - Configure the target host network
  • Step D - Download the binary to the target
  • Step E - Execute program(s) on the target

Boot Config. Download
  • Step B - Build the target binary (vmlinux)
  • Linux uses the make utility extensively.
  • Sources organized into subdirectories
  • vmlinux built from archives and libraries
  • If compressed, it is then called vmlinuz
  • Booter and optional RAM disk are then added and
    the composite is named zvmlinuz, zImage or
  • Some boards need S-Records / other formats
  • Convert as needed (zsrec utility, etc...)

Boot Config. Download
  • Step C Configure the host network capabilities
  • BOOTP (uses DHCP)
  • TFTP Daemon
  • NFS Information
  • Minicom
  • Refer to the MontaVista Linux Professional
    Edition Users Guide and Quick Start Guide for
    your LSP

Boot Config. Download
  • Step D Download the binary to the target
  • Configure the target board (as previously
  • Configure any host daemons (as previously
  • Interconnect host and target
  • Activate the targets firmware to retrieve the
    previously built zImage binary file and transfer
    control into it
  • The first part of zImage, the Linux Boot Loader,
    uncompresses Linux and places it at the
    appropriate memory address

Boot Config. Download
  • Step D Download the binary to the target
  • The Linux Boot Loader also uncompresses the RAM
    disk image, if present, and places it in memory
  • Finally, the Linux Boot Loader transfers control
    to the uncompressed Linux image
  • (vmlinux) along with a command line describing
    the RAM disk image (if present)
  • Linux initializes itself including the hardware
    Memory Management Unit (MMU) that translates
    logical (or virtual) addresses into physical (or
    real addresses.)

Loading Image Loader
Loading Linux Boot Loader
Loading Linux Startup
Boot Config. Download
  • Step E Execute program(s) on the target
  • Linux mounts the initial file system from RAM
    Disk, or NFS Disk, or Local Disk.
  • Linux, in init/main.c searches for the init first
    as /sbin/init, then as /etc/init, then /bin/init
    and finally /bin/sh (any of which could be a
    binary executable, a shell script, or any other
    file that Linux knows how to execute) and then
    executes it.
  • Typically, it is the /sbin/init program that is
    executed at this point.
  • /sbin/init processes the /etc/inittab file. See
    man init and man inittab for complete details on
    starting your own application programs via the
    init process.

Development Tools
  • Kdevelop
  • Enhanced for development of remote targets by
  • Integrated Development Environment (IDE)
  • Microsoft Visual C -like
  • Brief tutorial included in MontaVista Linux
    Professional Edition, Reference Guide
  • More extensive instructions are available in the
    on-line help within kdevelop itself.
  • Works best with C and C
  • Works with Assembler also

Development Tools
  • GNU gcc and g
  • gcc - C Compiler
  • g - C Compiler
  • A family of compilers for various target CPUs
  • A front-end for the build process including
    preprocessor, compiler, assembler and linker
  • Assembler and Linker
  • as
  • ld

Development Tools
  • Binutils a collection of binary tools
  • ar - Manages object file archives
  • nm - List symbols from object files
  • objcopy - Copy and translate object files
  • size - List text, data and bss sizes
  • strip - Remove symbols
  • addr2line - Convert addresses to file and line

Development Tools
  • make and Makefile
  • Traditional Unix tool
  • Almost anything you can do by hand (and then
    some) can be done through a Makefile
  • Lots of good books from which to learn
  • Notably "Managing Projects with Make" (Pub

Development Tools
  • A simple Makefile example
  • Makefile for ferret
  • CCxsacle_be-gcc
  • TARGET/opt/hardhat/devkit/arm/xscale_be/target
  • all install
  • install ferret
  • cp ferret (TARGET)
  • ferret ferret.c Makefile
  • (CC) -D_REENTRANT -O lt -o _at_ -lpthread
  • clean
  • - rm -f ferret.o ferret (TARGET)/ferret

Development Tools
  • Source Debugging
  • gdb (on host) with gdbserver (on target)
  • Preparing the object files (compiling with -g and
    ggdb option)
  • No optimization makes it easier to follow
    execution but performance may change dramatically
    when recompiled with full optimization
  • Full optimization may lead to surprising leaps
    and jumps when executing and "watching" with gdb
  • Optimization is optional for user-level
    applications but in the kernel it is mandatory.

Development Tools
  • Source Debugging
  • Starting the gdbserver on the target
  • Receives requests from gdb on host
  • Sends answers to gdb on host
  • gdbserver is very small
  • Symbol table and source files on host system
  • Full (-g or -ggdb) contents needed only on host
  • Only the executable binary is on the target
  • Connecting gdb and gdbserver
  • DDD GUI front-end for gdb

Development Tools
  • Learning more about gdb
  • The GNU Web-Site, http//
  • Books, see Beginning Linux Programming, Richard
    Stones and Neil Matthew , WROX Press, Ltd.,
  • Use the help command in gdb itself.

Development Tools
  • Target Configuration Tool (TCT)
  • The tool that customize your Kernel and file
  • Features
  • Project and Configuration Management
  • Kernel Configure
  • Package Selector
  • Dependencies Check
  • The targetpkg Utility
  • Library Optimzation Tool (LOT)

Development Tools
  • Linux Trace Toolkit (LTT)
  • Fully-featured tracing system for the Linux
    kernel. It includes both the kernel components
    required for tracing and the user-level tools
    required to view the traces.
  • Micro-second event time-stamps
  • Minimal performance overhead (lt 2.5 ).
  • Multi-platform support
  • Friendly GUI with event graph, system and
    per-process analysis, and raw event descriptions.

Development Tools
  • Linux Trace Toolkit (LTT) Usage Steps
  • Enable Linux "Kernel Tracing" configuration
  • Create the tracer device entry in target's /dev
    if they are not available in your file system.
  • Start the trace daemon in targettracedaemon
    -ts10 /dev/tracer ./out.trace ./out.proc
  • Run "tracevisualizer" in host and load the above
    out.trace and out.proc files

Development Tools
  • Kernel GDB (KGDB)
  • Source debugging of the Kernel
  • Requirements
  • Enabling the CONFIG_KGDB entry in the Kernel
    Hacking section
  • Recompile with -ggdb
  • Enable frame pointers
  • Connect serial port
  • Download and boot target
  • Launch DDD and gdb to use the serial port
  • Upon connection, set breakpoints and go
  • Kernel Modules Debugging

File Systems
  • File Systems Supported (partial list)
  • EXT2/3
  • ReiserFS
  • XFS
  • CramFS
  • Network File System (NFS)

File Systems
  • How Do I Enable a Local Root File System?
  • A practice Use ramdisk as root file system
  • Kernel configuration
  • Edit kernel bootup command line option
  • Block devices enable RAMDISK support, init
    ramdisk support, default ramdisk size 4096kB
  • File Systems Disable network file system as root
  • Networking Options Disable IP auto configuration
    in bootp

File Systems
  • Use ramdisk as root file system (contd)
  • Use TCT to generate my root file system, convert
    to ext2 format and compress it.
  • Download to the target and run    ltRedbootgt load
    r v b 0xnnnnnnnn ltramdiskgt
  • ltRedbootgt load r v b 0xuuuuuuuu
    ltkernelgt    ltRedbootgt go 0xuuuuuuuu

File Systems
  • Use ramdisk as root file system (contd)
  • rm -rf /tmp/tmpmnt
  • mkdir /tmp/tmpmnt
  • rm -rf /tmp/ramrootfs
  • dd if/dev/zero of/tmp/ramrootfs bs1k
  • mke2fs -F -m 0 -i 2000 /tmp/ramrootfs
  • mount -o loop -t ext2 /tmp/ramrootfs /tmp/tmpmnt
  • cd /tmp/tmpmnt
  • cp -av /my_workdir/my_filesystem/pxa250/fs1/ .
  • cd /tmp
  • umount /tmp/tmpmnt
  • cat /tmp/ramrootfs gzip -9 gt /tftpboot/pxa250.ra

File Systems
  • Use JFFS/JFFS2 as root file system
  • You have to use /opt/hardhat/devkit/arm/xscale_be
    /target/sbin/mkfs.jffs2 to make your jffs2 file
  • The mkfs.jffs2 needs /usr/lib/
    /lib/ /lib/
  • Bootup your target with rootnfs or /dev/ram
    which contains the above binaries and your target
    file system directory.
  • Run /usr/sbin/mkfs.jffs2 -d lttarget dirgt -o

File Systems
  • Use JFFS/JFFS2 as root file system (contd)
  • Rebuild the kernel with "root/dev/mtdblock? rw
  • Use Redboot commands to download the my.jffs2 and
    the new kernel
  • Reboot the system with the new kernel and jffs2
    file system.

Kernel Modules
  • An object file (e.g., myfile.o) that is
    dynamically loaded and added to the kernel at
  • Often used to add/remove optional items to/from
    the system such as device drivers
  • Useful when kernel footprint or alternative
    drivers is an issue
  • May also be used with proprietary code to avoid
    licensing issues in GPL

Kernel Modules
  • Often have a custom /proc interface built-in to
    the module
  • Written by the kernel module programmer
  • Can be written to provide both a read and a write
  • Typically used initially to assist in kernel
    module debugging
  • But the long-term use is typically to help the
    system administrator either by providing
    information about system configuration and
    operation, and allowing parameters in the kernel
    module to be modified as may be needed by the

Kernel Modules
  • Loading and Unloading Modules
  • insmod - Install (load) a module
  • rmmod - Remove (unload) a module
  • lsmod - List installed modules
  • depmod - Show dependencies of a module
  • modprobe - Loads a module and its dependencies
  • modinfo - Displays information about a module
  • Start-Up
  • insmod may be used in /etc/init.d/ and

Kernel Modules
  • A Simple Kernel Module
  • include ltlinux/module.hgt
  • include ltlinux/init.hgt
  • include ltlinux/kernel.hgt
  • static int __init my_init_module(void)
  • printk("lt1gt Yup, Im here!\n") / Logged to
    /dev/console /
  • return 0
  • static void __exit my_cleanup_module(void)
  • printk("lt1gt And now Im leaving.\n") / Logged
    to /dev/console /
  • module_init(my_init_module)
  • module_exit(my_cleanup_module)

Kernel Modules
  • Kernel Module Compiling
  • Kernel modules need to be built using the kernel
    headers rather than the user-space headers
  • ltarchitecture-prefixgt-gcc -D__KERNEL__ -Wall -O2
    -I ltpath-to-kernelgt/include -I ltpath-to-kernelgt/ar
    ch/ltarchitecturegt -DMODULE -c mymod.c
  • When more than one '-I' option is used, the
    directories are scanned in left-to-right order.
    These directories are searched before the
    standard system directories.

Kernel Modules
  • Compiling with version information is only
    necessary when compiling a module for a kernel
    that has "CONFIG_MODVERSIONS" enabled.
  • Version mismatch
  • insmod mymod.o
  • mod1.o kernel-module version mismatch
  • mod1.o was compiled for kernel version
  • while this kernel is version 2.4.17_mvl21-cllf.
  • Solutions
  • Insmod f
  • recompile the module with "version information"
    in the kernel

Kernel Modules
  • How do I compile a module with "version
    information" in the kernel?
  • ltarchitecture-prefixgt-gcc -D__KERNEL__ -Wall -O2
    -Iltpath-to-kernelgt/include -I ltpath-to-kernelgt/arc
    h/ltarchitecturegt -DMODULE -DMODVERSIONS -include
    ltpath-to-kernelgt/include/linux/version.h -c

Kernel Modules
  • depmod - Module Dependencies Database
  • Creates a database of module dependencies
  • Scans modules in /lib/modules
  • Generates /lib/modules//modules.dep
  • will be replaced by the kernel version and
    build number
  • Update when adding new modules to the system that
    should be automatically inserted
  • Modules that will be loaded manually do not need
    to be in the database

Kernel Modules
  • depmod Example
  • insmod lp
  • ./lp.o unresolved symbol parport_register_device_
  • ./lp.o unresolved symbol parport_release_R93e3522
  • ./lp.o unresolved symbol parport_claim_or_block_R
  • ./lp.o unresolved symbol parport_unregister_devic
  • ./lp.o unresolved symbol parport_enumerate_R6a5c1
  • depmod -a
  • /lib/modules/2.2.12-20b/modules.dep
  • /lib/modules/2.2.12-20b/misc/lp.o

Kernel Modules
  • modprobe - Load Module and its Dependencies
  • May be used instead of insmod
  • Check dependency database
  • Loads dependent modules in the correct order
  • Checks /etc/conf.modules for parameters
  • Can pass additional parameters

Kernel Modules
  • Passing Values to the Module
  • modprobe parport_pc.o demo1
  • This works with insmod also
  • In the modules source
  • / parport_pc.c /
  • ifdef MODULE
  • static int demo 0
  • MODULE_PARM(demo, "i")
  • MODULE_PARM_DESC(demo, "Demo variable, defaults
    to 0")
  • endif

Kernel Modules
  • Add Module via Linux Configuration Process
  • Used when a kernel module must be built at the
    same time as the kernel Not required for simple
    testing of the kernel module
  • Steps
  • First Add a selection to the kernel
  • Second Add the object module to kernel Makefile
  • Third Configure and Build the Linux kernel

Kernel Modules
  • Add Module via Linux Configuration Process
  • Step 1 Add a selection to the configuration
  • Locate the appropriate file
  • Add the appropriate lines for your module
  • To allow "y", "m" or "n" selection
  • tristate User-readable description goes here
  • Refer to Documentation/ and

Kernel Modules
  • Add Module via Linux Configuration Process
  • Step 2 Add the object module to Makefile
  • Determine appropriate ltpath-to-kernelgt/
  • Add command to include your module
  • obj-(CONFIG_YOURSYMBOL) yourfilename.o
  • Copy source files to same directory
  • If necessary, add compile options, etc. to

Kernel Modules
  • Add Module via Linux Configuration Process
  • Step 3 Build the linux kernel
  • make config OR make menuconfig OR make xconfig OR
    make oldconfig
  • make dep OR make depend
  • make bzImage OR make zImage
  • make modules
  • make INSTALL_MOD_PATH/opt/hardhat/devkit/mips/fp_
    le/target/lib/modules install_modules
  • the modules should end up in the targets
    /lib/modules directory.

Kernel Modules
  • Kernel Modules Source Level Debugging
  • Instructs insmod to generate a load map for the
    module when it gets loaded into memory.
  • target linux insmod m module.o gt
  • target linux grep .text
  • gdb add-symbol-file module.o XXXXXXXX
  • XXXXXXXX address of .text section from grep
  • precludes the ability to debug the modules

MontaVista Realtime
  • MontaVista provides following improvements for
    real-time performance of the Linux kernel
  • MontaVista Real-Time Scheduler
  • To meet real-time performance requirements while
    preserving the standard Linux programming model
    and APIs.
  • All that necessary is to use the standard Linux
    real-time priority options provided within its
    POSIX function calls.
  • Preemptible Kernel
  • Reduces the latency of the kernel when reacting
    to real-time or interactive events by allowing a
    low-priority process to be preempted, even if it
    is in kernel mode executing a system call.
  • This feature allows applications that need
    real-time response such as audio and other
    multimedia applications to run more reliably,
    even when the system is under an increased load
    due to other lower-priority processes.

MontaVista Realtime
  • In the following instances, preemption should not
    occur, and the Preemptible Kernel does not allow
  • while handling interrupts
  • while doing bottom half processing
  • while holding a spinlock, writelock, or readlock
  • while the kernel is executing the scheduler
  • At all other times, the MontaVista algorithm
    allows preemption. Also, whenever the system
    exits from one of the above states, it tests to
    see if preemption is called for. If so, the
    current task is preempted.

MontaVista Realtime
  • Enabling the MontaVista Real-Time Scheduler
  • Start make menuconfig or make xconfig, enable
    Real Time Scheduler.
  • Enter a value for the Maximum Priority option.
  • Save your changes.
  • Rebuild the kernel

MontaVista Realtime
  • To enable the MontaVista Preemptible Kernel,
    complete the following steps
  • Start make menuconfig or make xconfig
  • Select General setup
  • Enable Preemptible kernel support
  • Enable Break selected locks
  • Rebuild the kernel

MontaVista Realtime
  • Pthread Programming
  • The P is for POSIX, Portable Operating System
  • IEEE Standard
  • Section 1003.1c defines Pthreads

MontaVista Realtime
  • Threads, An Alternative View
  • Some engineers prefer to view things differently
    in Linux. Even though Linux is a process-based
    operating system, they choose to view a process
    as a container.
  • In this view, the process does not execute code.
    It simply provides the space and other properties
    in which threads may execute.
  • When a process is created (via fork) in this
    view, one thread of execution is automatically

MontaVista Realtime
  • Threads, An Alternative View (contd)
  • That initial thread begins at the place we call
    main. It could then create additional threads
    within the same process.
  • When any thread wishes to terminate, it calls
    pthread_exit. That one thread is then terminated.
  • If any one thread wishes to terminate the entire
    process (and all threads within it), that thread
    may call exit.
  • Finally, if all threads, one by one, call
    pthread_exit, when the last thread is gone, Linux
    will remove the process.

MontaVista Realtime
  • POSIX Thread Execution Priorities
  • The greater the numerical priority value, the
    more important the thread.
  • POSIX recommends at least 99 priorities above
    zero (MontaVista supports range 992047)
  • root priviledge is required to use the elevated
    priority numbers (1-99).
  • SCHED_FIFO or SCHED_RR must be used at elevated
    priority numbers.
  • SCHED_OTHER ("fairness") is not permitted at
    elevated priorities.

MontaVista Realtime
  • POSIX Policies
  • Processes (threads) run First In First Out
  • use the elevated priority numbers
  • Most commonly used "real-time" scheme
  • Used when process(es) are known to use relatively
    brief "bursts" of CPU time
  • Permits the highest priority process (thread) to
    run "at will"
  • Starvation of lower priorities can occur

MontaVista Realtime
  • POSIX Policies
  • SCHED_RR (Round Robin)
  • SCHED_RR is SCHED_FIFO with "quanta"
  • A "Quanta" is a period of time after which the
    process (thread) is moved behind others of the
    same priority
  • May be used when the process(es) are known to
    have long periods of intensive execution and more
    than one process uses this priority
  • Also use the elevated priority numbers
  • Processes run until they say they want to wait,
    or until their quanta is exhausted

MontaVista Realtime
  • POSIX Policies
  • In Linux, it is implemented as the normal
    scheduling policy (lets be fair and let everyone
  • Only available at POSIX priority zero
  • Lower priority than SCHED_FIFO and SCHED_RR

MontaVista Realtime
  • Choosing Priorities for SCHED_FIFO, SCHED_RR
  • High priorities (99--)
  • I/O intensive (reactive)
  • Critical (time-sensitive) operations
  • High repetition rate
  • NOTE Processes MUST wait -- busy spins are bad

MontaVista Realtime
  • Choosing Priorities for SCHED_FIFO, SCHED_RR
  • Low priorities (1)
  • Less vital (less catastrophic if not done)
  • CPU intensive operations
  • Consider SCHED_RR
  • Priority zero
  • Must use SCHED_OTHER
  • Non-realtime activities
  • Batch operations (compiling, etc...)
  • Time-consuming computations
  • Human interface

MontaVista Realtime
  • Pthread Coding Requirements
  • Include files
  • unistd.h
  • pthread.h
  • semaphore.h
  • Compiler flags -D_REENTRANT
  • Required for some architectures
  • Ignored when unnecessary

MontaVista Realtime
  • Pthread Functions Briefly
  • pthread_create - Create a new thread
  • pthread_exit - "Me" exit
  • pthread_join - Wait for a given thread to
  • pthread_cancel - Attempt to terminate a thread
  • pthread_self - Who am I?
  • pthread_detach - Save no resources if I
    pthread_exit later (cant be joined)

MontaVista Realtime
  • Pthread Attribute Preparation
  • int pthread_attr_init(pthread_attr_t attr)
  • Setup pthread attribute object
  • Usually defaulted at pthread_create
  • Can be changed as thread runs
  • sched_setscheduler()
  • sched_setparam()

MontaVista Realtime
  • Making Yourself Realtime
  • include ltsched.hgt
  • struct sched_param sched_params
  • / Change our priority to as high as possible and
    use SCHED_FIFO /
  • sched_params.sched_priority sched_get_priority_m
  • if (0 ! sched_setscheduler(getpid(), SCHED_FIFO,
  • printf("sched_setscheduler failed (YOU MUST BE
  • exit(1)

MontaVista Realtime
  • Study more
  • Posix.4 Programming for the RealWorld, Bill O.
    Gallmeister, OReilly Associates,
  • Pthreads Programming, Bradford Nichols, Dick
    Buttlar, and Jacqueline Proulx Farrell, OReilly
    Associates, Inc., 1-56592-115-1.

  • /opt/hardhat/devkit/arm/xscale_le/target
  • /etc/bootptab, /etc/xinetd.d/bootps
  • /etc/exports
  • /etc/xinetd.d/tftp
  • /etc/dhcpd.conf
  • /etc/init.d/nfs restart
  • /etc/redhat-release
  • /mnt/cdrom/bin/hhl-host-install
  • Redbootgt fis create fis delete fis list