To Next PageTo Next PageTo Previous PageTo Previous Page
Loading...
Need help?Do you have a question about the Linux Pocket Linux Guide and is the answer not in the manual?
General| Title | Linux Pocket Guide |
|---|---|
| Author | Daniel J. Barrett |
| Publisher | O'Reilly Media |
| Format | Paperback |
| Language | English |
Legal text regarding document usage and permissions.
Legal text disclaiming warranties and responsibilities for document use.
Overview of the guide's purpose and target audience.
Lists necessary skills for following the guide.
Explains the chapter structure: Analysis, Design, Construction, Implementation.
Outlines the objectives and constraints of the Pocket Linux project.
Discusses the limitations and advantages of the project's design.
Defines the goals for the initial minimal working system.
Outlines the components needed for a basic boot/root disk set.
Focuses on essential components, ignoring complexity.
Details requirements for the boot disk, including GRUB and kernel.
Describes requirements for the root disk, including BASH and /dev files.
Steps for building the boot and root disk floppies.
Instructions for formatting and mounting the boot diskette.
Steps for configuring and compiling the Linux kernel.
Compiling and stripping the BASH shell for the root disk.
Steps to start and test the prototype system.
Detailed instructions to boot the Pocket Linux system.
Discusses limitations of the prototype and goals for space saving.
Outlines techniques for space saving: shared libraries, stripped binaries, compressed filesystem.
Rebuilding BASH to use shared libraries.
Using a ramdisk approach for a compressed filesystem.
Steps for building the compressed root filesystem using a ramdisk.
Reconfiguring BASH without static linking.
Unmounting, dumping, and compressing the ramdisk.
Steps to boot and test the space-optimized system.
Booting the system with the compressed root disk.
Discusses the need to add more utilities to the root disk.
Plans for adding common external commands like cat, ls, mkdir, rm.
Using FHS to identify necessary commands.
Instructions for downloading package source code.
Steps for building and installing new utilities.
Setting up a temporary directory for building.
Compiling and installing core utilities.
Compressing the updated root filesystem.
Steps to boot and test the system with new utilities.
Booting the system with a read-write root filesystem.
Verifying the functionality of newly added utilities.
Discusses the need for disk mounting and checking capabilities.
Planning to implement fsck and mount utilities.
Identifying fsck, mount, umount based on FHS.
Designing a script to check and mount filesystems.
Identifying necessary files like /etc/fstab and /dev entries.
Creating the fstab file for filesystem configuration.
Steps for installing utilities and creating configuration files.
Compiling and installing fsck and mke2fs.
Compiling and installing mount, umount, and others.
Setting up filesystem configuration and tracking files.
Creating the `local_fs` startup script.
Compressing the updated root filesystem.
Steps to boot and test the system with mounting capabilities.
Booting the system and checking startup scripts.
Verifying the automated filesystem mounting script.
Discusses improving system startup, shutdown, and manual processes.
Planning to automate boot parameters, use init daemon, and implement graceful shutdown.
Identifying init daemon, shutdown, halt, reboot.
Creating `menu.lst` for automated booting.
Planning System V style init scripts.
Steps for creating startup scripts and configuring the system.
Writing the `menu.lst` file.
Configuring the init daemon's behavior.
Creating the main runlevel script.
Adapting the mounting script for start/stop.
Organizing startup scripts into runlevel directories.
Steps to boot and verify automated startup/shutdown.
Booting the system with automated configuration.
Checking if filesystems are mounted and hostname is set.
Performing a graceful system shutdown.
Discusses moving from single-user to multi-user mode.
Planning for multi-user capability and virtual consoles.
Outlining the steps for user login.
Preparing necessary configuration files and device nodes.
Creating /dev entries for virtual consoles.
Creating a minimal passwd file for users.
Guidelines for user/group naming and ID assignment.
Identifying libraries required for login, like libnss_files.
Steps for implementing multi-user support.
Configuring `inittab` for multiple virtual terminals.
Creating device nodes for virtual terminals.
Creating essential configuration files like `nsswitch.conf`.
Applying appropriate permissions for multi-user security.
Compressing the system with multi-user support.
Steps to boot and test multi-user features.
Creating a new user account and group.
Identifying missing commands according to FHS, like `more`, `ps`, `sed`, `ed`.
Planning to add the missing commands, including a custom `more` script.
Designing a simple shell script to emulate the `more` command.
Identifying sources for `ps`, `sed`, and `ed` packages.
Steps for implementing the missing utilities.
Creating the shell script for the `more` command.
Compiling and installing the `ps` utility.
Compiling and installing the `sed` utility.
Compiling and installing the `ed` editor.
Setting permissions for the new utilities.
Compressing the system with the new utilities.
Using the custom `more` script with `dmesg` and `local_fs`.
Demonstrating the `ps` command.
Using `sed` to modify `/etc/passwd`.
Summarizes the achievements of the project.
Discusses future expansion possibilities for Pocket Linux.
Discusses expanding Pocket Linux to run applications like mp3blaster.
Planning for audio hardware support, mp3blaster space, and audio file access.
Kernel and /dev configuration for sound cards.
Building a kernel with built-in audio support.
Strategies for adding mp3blaster, including compressed floppies.
Loading compressed images from floppy to ramdisk.
Handling audio files and potential CD-ROM support.
Identifying libraries and terminfo for mp3blaster.
Steps to build the enhanced system.
Building a new kernel with additional hardware support.
Configuring kernel options for audio and CD-ROM.
Compiling and installing gunzip.
Creating a script to load the /usr image.
Building the /usr disk with mp3blaster.
Setting up a staging directory for the /usr disk.
Downloading and compiling mp3blaster.
Creating a floppy for sample audio files.
Steps to test the hosted application.
Booting the system with the enhanced diskettes.
Using mp3blaster to play an audio file.
Explains the purpose and freedoms granted by the license.
Defines terms and scope of the license.
Conditions for copying and distributing the document verbatim.
Guidelines for creating and distributing modified versions.
Rules for combining this document with others.
Procedures for creating document collections.
Guidelines for distributing translated versions.
Conditions under which the license can be terminated.
Information on future license versions.