Post Mortem Crash Analysis In Linux

Download ---- pdf----Post Mortem Crash Analysis In Linux

Post Mortem Crash Analysis


Abstract
To improve the quality and reliability of embedded systems it is important to
gather information about errors in units already sold and deployed To achieve
this, a system for transmitting error information from the customer back to the
developers is needed, and the developers must also have a set of tools to analyze
the error reports The purpose of this master thesis was to develop a fully functioning
demonstration system for collection, transmission and interpretation of error reports
from Axis network cameras using the Linux operating system The system has been shown
to handle both kernel and application errors and conducts automatic analysis of received
data It also uses standard HTTP protocol for all network transfers making it easy to use
even on firewalled networks




Contents
Introduction
Problem description
Problem analysis
Background
Kernel crashes
User space crashes
Core dump generation under Linux
Existing products
netdump
Other systems
Windows XP
MacOS X
Solaris
System
Target platform
Desired information
User space errors
Core dump compression
Run length encoding
LZMA
The netcore file system
Kernel errors
Extending the kernel Oops
Core dump analysis
Linux core files
Call trace and the CRIS architecture
The coreinfo tool
Fingerprinting
Core dump fingerprinting
Recursion errors
Oops fingerprinting
Customer server
Axis server
Validation
Validation of crash reports
User space crashes
Kernel crashes
Compression
Conclusion
Discussion
Signal handlers
Patents
Further improvements

Monolithic kernel vs Microkernel

Download ---- pdf----- Monolithic kernel vs Microkernel

Monolithic kernel vs. Microkernel


This document explains the two main kernel architectures of
operating systems: the monolithic kernel and the microkernel.
Starting with an introduction about the term "kernel"
itself and its meaning for operating systems as a whole, it
continues with a comparison of bene ts and disadvantages
of both architectures, rounded up by a list of popular implementations.


COMPARISON BETWEEN BASIC CON­
CEPTS OF THE TWO APPROACHES


Inter Process Communication
Memory Managment
Security and Stability
I/O Communication
Extensibility and Portability
IMPLEMENTATIONS
Monolithic kernel
GNU/Linux
Windows NT
Microkernel
QNX
Hybrid kernel
Mach

Unreliable Guide To Hacking The Linux Kernel

Download-----pdf----Unreliable Guide To Hacking The Linux Kernel

Unreliable Guide To Hacking The Linux Kernel
by Paul Rusty Russell


Table of Contents
Introduction
The Players
User Context
Hardware Interrupts (Hard IRQs)
Software Interrupt Context: Bottom Halves, Tasklets, softirqs
Some Basic Rules
ioctls: Not writing a new system call
Recipes for Deadlock
Common Routines
printk() include/linux/kernelh
copy_[to/from]_user() / get_user() / put_user() include/asm/uaccessh
kmalloc()/kfree() include/linux/slabh
current include/asm/currenth
local_irq_save()/local_irq_restore() include/asm/systemh
local_bh_disable()/local_bh_enable() include/asm/softirqh
smp_processor_id()/cpu_[number/logical]_map() include/asm/smph
__init/__exit/__initdata include/linux/inith
__initcall()/module_init() include/linux/inith
module_exit() include/linux/inith
MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT include/linux/moduleh
Wait Queues include/linux/waith
Declaring
Queuing
Waking Up Queued Tasks
Atomic Operations
Symbols
EXPORT_SYMBOL() include/linux/moduleh
EXPORT_SYMTAB
Routines and Conventions
Double-linked lists include/linux/listh
Return Conventions
Breaking Compilation
Initializing structure members
GNU Extensions
C++
#if
Putting Your Stuff in the Kernel
Kernel Cantrips
Thanks

The Linux Kernel API

Download ---- pdf---The Linux Kernel API
The Linux Kernel API

Table of Contents
The Linux VFS
The Directory Cache
d_invalidate
d_find_alias
prune_dcache
shrink_dcache_sb
have_submounts
shrink_dcache_parent
d_alloc
d_instantiate
d_alloc_root
d_lookup
d_validate
d_delete
d_rehash
d_move
__d_path
is_subdir
find_inode_number
d_drop
d_add
dget
d_unhashed
Inode Handling
__mark_inode_dirty
write_inode_now
clear_inode
invalidate_inodes
get_empty_inode
iunique
insert_inode_hash
remove_inode_hash
iput
bmap
update_atime
make_bad_inode
is_bad_inode
Registration and Superblocks
register_filesystem
unregister_filesystem
__wait_on_super
get_super
get_empty_super


Linux Networking
Socket Buffer Functions
skb_queue_empty
skb_get
kfree_skb
skb_cloned
skb_shared
skb_unshare
skb_peek
skb_peek_tail
skb_queue_len
__skb_queue_head
skb_queue_head
__skb_queue_tail
skb_queue_tail
__skb_dequeue
skb_dequeue
skb_insert
skb_append
skb_unlink
__skb_dequeue_tail
skb_dequeue_tail
skb_put
skb_push
skb_pull
skb_headroom
skb_tailroom
skb_reserve
skb_trim
skb_orphan
skb_queue_purge
__skb_queue_purge
dev_alloc_skb
skb_cow
skb_over_panic
skb_under_panic
alloc_skb
__kfree_skb
skb_clone
skb_copy
skb_copy_expand
Socket Filter
sk_run_filter


Network device support
Driver Support
init_etherdev
dev_add_pack
dev_remove_pack
__dev_get_by_name
dev_get_by_name
dev_get
__dev_get_by_index
dev_get_by_index
dev_alloc_name
dev_alloc
netdev_state_change
dev_load
dev_open
dev_close
register_netdevice_notifier
unregister_netdevice_notifier
dev_queue_xmit
netif_rx
net_call_rx_atomic
register_gifconf
netdev_set_master
dev_set_promiscuity
dev_set_allmulti
dev_ioctl
dev_new_index
register_netdevice
netdev_finish_unregister
unregister_netdevice
Based Network Cards
ei_open
ei_close
ei_interrupt
ethdev_init
NS_init
Synchronous PPP
sppp_input
sppp_close
sppp_open
sppp_reopen
sppp_change_mtu
sppp_do_ioctl
sppp_attach
sppp_detach


Module Loading
request_module


Hardware Interfaces
Interrupt Handling
disable_irq_nosync
disable_irq
enable_irq
probe_irq_mask
MTRR Handling
mtrr_add
mtrr_del
PCI Support Library
pci_find_slot
pci_find_device
pci_find_class
pci_find_parent_resource
pci_set_power_state
pci_enable_device
MCA Architecture
MCA Device Functions
mca_find_adapter
mca_find_unused_adapter
mca_read_stored_pos
mca_read_pos
mca_write_pos
mca_set_adapter_name
mca_set_adapter_procfn
mca_is_adapter_used
mca_mark_as_used
mca_mark_as_unused
mca_get_adapter_name
mca_isadapter
mca_isenabled
MCA Bus DMA
mca_enable_dma
mca_disable_dma
mca_set_dma_addr
mca_get_dma_addr
mca_set_dma_count
mca_get_dma_residue
mca_set_dma_io
mca_set_dma_mode


The Device File System
devfs_register
devfs_unregister
devfs_mk_symlink
devfs_mk_dir
devfs_find_handle
devfs_get_flags
devfs_get_maj_min
devfs_get_handle_from_inode
devfs_generate_path
devfs_get_ops
devfs_set_file_size
devfs_get_info
devfs_set_info
devfs_get_parent
devfs_get_first_child
devfs_get_next_sibling
devfs_auto_unregister
devfs_get_unregister_slave
devfs_register_chrdev
devfs_register_blkdev
devfs_unregister_chrdev
devfs_unregister_blkdev


Power Management
pm_register
pm_unregister
pm_unregister_all
pm_send
pm_send_all
pm_find


Miscellaneous Devices
misc_register
misc_deregister


VideoLinux
video_register_device
video_unregister_device


Sound Devices
register_sound_special
register_sound_mixer
register_sound_midi
register_sound_dsp
register_sound_synth
unregister_sound_special
unregister_sound_mixer
unregister_sound_midi
unregister_sound_dsp
unregister_sound_synth


x UART Driver
register_serial
unregister_serial


Z Support Library
z_interrupt
z_sync_open
z_sync_close
z_sync_dma_open
z_sync_dma_close
z_sync_txdma_open
z_sync_txdma_close
z_describe
z_init
z_shutdown
z_channel_load
z_null_rx
z_queue_xmit
z_get_stats

Standalone Device Drivers in Linux

Download ---- pdf----Standalone Device Drivers in Linux
Standalone Device Drivers in Linux


Introduction
Existing systems
Techniques for writing stand-alone drivers in Linux
Using Kernel Modules
Building modules outside of the kernel tree
Synchronizing kernel versions
Exporting symbols from a module
Installing modularized device drivers
Kernel version compatibility
Standards for installing rc.d scripts
Binary Compatibility
Cross OS compatibility
A Sample Makefile
A sample installation script

Linux Kernel Internals 2.4

Download ----pdf---Linux Kernel Internals 2.4

Linux Kernel Internals


Table of Contents


Booting
Process and Interrupt Management
Virtual Filesystem (VFS)
Linux Page Cache
IPC mechanisms
Booting
Building the Linux Kernel Image
Booting: Overview
Booting: BIOS POST
Booting: bootsector and setup
Using LILO as a bootloader
High level initialisation
SMP Bootup on x
Freeing initialisation data and code
Processing kernel command line
Process and Interrupt Management
Task Structure and Process Table
Creation and termination of tasks and kernel threads
Linux Scheduler
Linux linked list implementation
Wait Queues
Kernel Timers
Bottom Halves
Task Queues
Tasklets
Softirqs
How System Calls Are Implemented on i Architecture?
Atomic Operations
Spinlocks, Read?write Spinlocks and Big?Reader Spinlocks
Semaphores and read/write Semaphores
Kernel Support for Loading Modules
Virtual Filesystem (VFS)
Inode Caches and Interaction with Dcache
Filesystem Registration/Unregistration
File Descriptor Management
File Structure Management
Superblock and Mountpoint Management
Example Virtual Filesystem: pipefs
Example Disk Filesystem: BFS
Execution Domains and Binary Formats
Linux Page Cache
IPC mechanisms
Semaphores
Semaphore System Call Interfaces
sys_semget()
sys_semctl()
sys_semop()
Non?blocking Semaphore Operations
Failing Semaphore Operations
Blocking Semaphore Operations
Semaphore Specific Support Structures
struct sem_array
struct sem
struct seminfo
struct semid_ds
struct sem_queue
struct sembuf
struct sem_undo
Semaphore Support Functions
newary()
freeary()
semctl_down()
IPC_RMID
IPC_SET
semctl_nolock()
IPC_INFO and SEM_INFO
SEM_STAT
semctl_main()
GETALL
SETALL
IPC_STAT
GETVAL
GETPID
GETNCNT
GETZCNT
SETVAL
count_semncnt()
count_semzcnt()
update_queue()
try_atomic_semop()
sem_revalidate()
freeundos()
alloc_undo()
sem_exit()
Message queues
Message System Call Interfaces
sys_msgget()
sys_msgctl()
IPC_INFO ( or MSG_INFO)
IPC_STAT ( or MSG_STAT)
IPC_SET
IPC_RMID
sys_msgsnd()
sys_msgrcv()
Message Specific Structures
struct msg_queue
struct msg_msg
struct msg_msgseg
struct msg_sender
struct msg_receiver
struct msqid_ds
struct msqid_ds
msg_setbuf
Message Support Functions
newque()
freeque()
ss_wakeup()
ss_add()
ss_del()
expunge_all()
load_msg()
store_msg()
free_msg()
convert_mode()
testmsg()
pipelined_send()
copy_msqid_to_user()
copy_msqid_from_user()
Shared Memory
Shared Memory System Call Interfaces
sys_shmget()
sys_shmctl()
IPC_INFO
SHM_INFO
SHM_STAT, IPC_STAT
SHM_LOCK, SHM_UNLOCK
IPC_RMID
IPC_SET
sys_shmat()
sys_shmdt()
Shared Memory Support Structures
struct shminfo
struct shm_info
struct shmid_kernel
struct shmid_ds
struct shmem_inode_info
Shared Memory Support Functions
newseg()
shm_get_stat()
shmem_lock()
shm_destroy()
shm_inc()
shm_close()
shmem_file_setup()
Linux IPC Primitives
Generic Linux IPC Primitives used with Semaphores, Messages,and Shared Memory
ipc_alloc()
ipc_addid()
ipc_rmid()
ipc_buildid()
ipc_checkid()
grow_ary()
ipc_findkey()
ipcperms()
ipc_lock()
ipc_unlock()
ipc_lockall()
ipc_unlockall()
ipc_get()
ipc_parse_version()
Generic IPC Structures used with Semaphores,Messages, and Shared Memory
struct kern_ipc_perm
struct ipc_ids
struct ipc_id

Linux Kernel Hash table Behaviour

Download Article----pdf----Linux Kernel Hash table Behaviour

Linux Kernel Hash Table Behavior:
Analysis and Improvements

The Linux kernel employs hash table data structures to store high-usage data objects such as pages, buffers, inodes, and others. In this report we find significant performance boosts with careful analysis and tuning of four critical kernel data structures.

Introduction
Methodology
Four critical hash tables
Page cache
Buffer cache
Dentry cache
Inode cache
Combination testing
Multiplicative hashing
A Little Theory

Understanding BizTalk Server 2006

Download ---pdf---Understanding BizTalk Server 2006

Understanding BizTalk Server 2006


INTRODUCING BIZTALK SERVER 2006
WHAT BIZTALK SERVER 2006 PROVIDES
HOWBIZTALK SERVER 2006 IS USED
THE BIZTALK SERVER 2006 ENGINE
CONNECTING SYSTEMS8
Sending and Receiving Messages: Adapters
Processing Messages: Pipelines
Choosing Messages: Subscriptions
DEFINING BUSINESS PROCESSES
Using Orchestrations
Using the Business Rules Engine
MANAGEMENT AND MONITORING
Installing BizTalk Server 2006
Creating Scalable Configurations
Managing Applications
Reporting On and Debugging Applications: Health and Activity Tracking
ENTERPRISE SINGLE SIGN-ON
INFORMATION WORKER TECHNOLOGIES
BUSINESS ACTIVITY MONITORING
BUSINESS ACTIVITY SERVICES
Trading Partner Management
Business Process Configuration
BIZTALK SERVER 2006 AND OTHER WINDOWS TECHNOLOGIES
BIZTALK SERVER 2006 AND WINDOWS WORKFLOWFOUNDATION
BIZTALK SERVER 2006 AND WINDOWS COMMUNICATION FOUNDATION

Object-Role Modeling an overview

Download --- pdf ----Object-Role Modeling an overview

Object-Role Modeling: an overview
Terry Halpin
Microsoft Corporation
This paper provides an overview of Object-Role Modeling (ORM), a fact-oriented method for performing information analysis at the conceptual level. The version of ORM discussed here is supported in Microsoft Visio for Enterprise Architects, part of Visual Studio .NET Enterprise Architect

Introducing BizTalk Server 2006 R2

Download Paper --- pdf----Introducing BizTalk Server 2006 R2

Introducing BizTalk Server


Contents
AN OVERVIEW OF BIZTALK SERVER
THE CHALLENGE: IMPROVING BUSINESS PROCESSES
ADDRESSING THE CHALLENGE: WHAT BIZTALK SERVER R PROVIDES
Application Integration in a Service-Oriented World
Business-to-Business Integration
Business Process Management
BIZTALK SERVER FUNDAMENTALS
CONNECTING SYSTEMS
Sending and Receiving Messages: Adapters
Processing Messages: Pipelines
Translating Messages: Data Mapping
DEFINING BUSINESS PROCESSES
Using Orchestrations
Using the Business Rule Engine
CREATING SCALABLE CONFIGURATIONS
MANAGING BIZTALK APPLICATIONS
Creating and Monitoring Applications
Examining Application History
ADDITIONAL BIZTALK SERVER TECHNOLOGIES
BUSINESS ACTIVITY MONITORING
USING EDI
WORKING WITH RFID
ENTERPRISE SINGLE SIGN-ON

An Overview of the Software Engineering Process and Tools in the Mozilla Project

Download article---- pdf----An Overview of the Software Engineering Process and Tools in the Mozilla Project

An Overview of the Software Engineering Process and Tools in the Mozilla Project


TheMozilla Project is an Open Source Software project which is dedicated to development of the Mozilla Web browser and application framework. Possessing one of the largest and most complex communities of developers among Open Source projects, it presents interesting requirements for a software process and the tools to support it. Over the past four years, process and tools have been refined to a point where they are both stable and effective in serving the project’s needs. This paper describes the software engineering aspect of a large Open Source project. It also covers the software engineering tools used in theMozilla Project, since theMozilla process and tools are intimately related. These tools include Bugzilla, a Web application designed for bug tracking, bug triage, code review and correction; Tinderbox, an automated build and regression testing system;
Bonsai, a tool which performs queries to the CVS code repository; and LXR, a hypertext-based source code browser.

Keywords: open source software, free software, software engineering, software process, software engineering tools, bug tracking, nightly builds, code versioning.

A Short Introduction to Cloud Platforms--Chappell

Download Article---pdf---A Short Introduction to Cloud Platforms--Chappell

A SHORT INTRODUCTION TO CLOUD PLATFORMS
AN ENTERPRISE-ORIENTED VIEW


Defining Terms: What is a Cloud Platform?
Cloud Platforms in Context: Three Kinds of Cloud Services
A General Model for Application Platforms
From On-Premises Platforms to Cloud Platforms
Examining Cloud Platforms
Cloud Foundation
Operating System
Local Support
Cloud Infrastructure Services
Storage
Integration
Identity
Cloud Application Services
SaaS Application Services
Search
Mapping
Other Application Services

SOFTWARE SERVICES IN THE MICROSOFT WORLD

Download paper ---pdf----SOFTWARE SERVICES IN THE MICROSOFT WORLD


SOFTWARE + SERVICES IN THE MICROSOFT WORLD
A TECHNOLOGY OVERVIEW FOR IT DECISION MAKERS


Introducing Software + Services
Defining Terms
S+S Today: Some Examples
S+S and Application Platforms
Software or Services? Weighing the Options
Exploiting an S+S World
A Closer Look at Services
Providing Services
Choosing Customers: Businesses or Consumers?
Choosing an Implementation Style: Single-Tenant or Multi-Tenant?
Pricing Services
Application Platforms in an S+S World
How S+S Changes Application Platforms: The BizTalk Example
Integration Using On-Premises Software: BizTalk Server
Integration Using Services: BizTalk Services
Examining SaaS Platforms
SaaS Platforms and Programmable Services
SaaS Platforms for Custom Applications
Looking Ahead: Microsoft’s Common Platform for On-Premises Software and SaaS

Using the Basic Work Flow

Download paper on Using the Basic Work Flow in pdf form

Using the Basic Workflow


Overview of the Basic Workflow
Creating a SilkTest Project
Enabling and Testing Extension Settings
Configuring the Recovery System
Recording a Testcase
Running a Testcase
Exploring Results

Drivers and the Kernel

Download----Drivers and the Kernel

Drivers and the Kernel

KERNEL ADAPTATION
WHY CONFIGURE THE KERNEL?
CONFIGURATION METHODS
TUNING A LINUX KERNEL
ADDING DEVICE DRIVERS
Device numbers
ADDING A LINUX DEVICE DRIVER
DEVICE FILES
Naming conventions for devices
LOADABLE KERNEL MODULES
BUILDING A LINUX KERNEL
Building the Linux kernel binary

The Direct Cost of Virtual Function Calls in C++

Download ---The Direct Cost of Virtual Function Calls in C++

The Direct Cost of Virtual Function Calls in C++


Abstract.
We study the direct cost of virtual function calls in C++ programs, assuming the standard
implementation using virtual function tables. We measure this overhead experimentally for a number of
large benchmark programs, using a combination of executable inspection and processor simulation. Our
results show that the C++ programs measured spend a median of 5.2% of their time and 3.7% of their
instructions in dispatch code. For “all virtuals” versions of the programs, the median overhead rises to
13.7% (13% of the instructions). The “thunk” variant of the virtual function table implementation reduces
the overhead by a median of 21% relative to the standard implementation. On future processors, these
overheads are likely to increase moderately.


Virtual function tables
Superscalar processors
Thunks
Branch prediction
Advanced superscalar execution
Co-scheduling of application code
Simulation scheme
Benchmarks
Processors
Experimental Results
Direct cost on P96
Instructions and cycles
Thunks
Generalization to other processors
Influence of branch penalty
Influence of branch prediction
Influence of load latency
Influence of issue width
Cost per dispatch

Migrating to Red Hat Enterprise Linux- Benefits and Guideline

Migrating to Red Hat Enterprise Linux- Benefits and Guideline (pdf)

Migrating to Red Hat Enterprise Linux - Benefits and Guidelines

Abstract
This white paper describes the features and benefits of the Red Hat Enterprise
Linux product family It briefly outlines factors that need to be considered when
planning a migration from a consumer Red Hat Linux release, such as 80 or
71, to an Red Hat Enterprise Linux family product It also discusses some of
the issues associated with migrating applications from proprietary Unix,
Microsoft Windows, and other Red Hat operating system environments

Table of Contents
Introduction
What is Red Hat Enterprise Linux?
Application Availability
Benchmarks
Migrating from Red Hat Linux
Red Hat Applications
Application Migration Issues
Professional Services1
Reference Documentation1

Migrating To Linux -Application Challenges and Solutions

Migrating To Linux -Application Challenges and Solutions --- pdf

MIGRATING TO LINUX:
APPLICATION CHALLENGES AND SOLUTIONS

SUMMARY
SECTION 2: LINUX TRENDS
Introduction
Business Drivers
Linux on the Server
Grid Computing for HPC Applicacions
Tracking IT Industry Leaders
Worldwide Migration
Linux on the Desktop
SECTION 3: WINDOWS APPLICATION MIGRATION
The Ideal Desktop Solution
Today’s Alternatives
EMULATORS
VIRTUAL MACHINES
SERVER-BASED, THIN-CLIENT SOLUTIONS
A Closer Look at GO-Global for Windows
HOW IT WORKS
LOWER TCO
CROSS PLATFORM COMPATIBILITY
FAST REMOTE ACCESS
DESKTOP INTEGRATION
SECTION 4: UNIX APPLICATION MIGRATION
The Ideal Solution
Today’s Alternatives
CLIENT-SIDE X SERVERS
VNC PRODUCTS
SERVER-BASED, THIN-CLIENT SOLUTIONS
A Closer Look at GO-Global for UNIX
HOW IT WORKS
LOWERING COSTS
MAXIMIZING VALUE
INCREASING SECURITY
FAST REMOTE ACCESS
SECTION 5: CONCLUSION  

Move applications from old-to-new same-to-same

Move applications from old-to-new same-to-same-----pdf

Move applications from old-to-new, same-to-same,

and similar-to-similar Linux distributions

Increase control and reduce the complexity of Linux application management

Windows Assembly Programming Tutorial

Click here to download :Windows Assembly Programming Tutorial
Windows Assembly Programming Tutorial
Version 102


Table of Contents
Introduction
Why Assembly?
Why Windows?
I Getting Started
Assemblers
Editors
II Your First Program
Console Version
Windows Version
ADDR vs OFFSET
III Basic Assembly
CPU Registers
Basic Instruction Set
Push and Pop
Invoke
Example Program
IV Basic Windows
Preliminaries
Macros
Functions
Variables
A Simple Window
V More Assembly and Windows
String Manipulation
File Management
Memory
Example Program
Controls
Additional Resources
WWW
Books
MASM32
MSDN Library
Newsgroups
IRC