Showing posts with label HP/UX. Show all posts
Showing posts with label HP/UX. Show all posts
Sunday, August 14, 2011
Turn on telnet service on for a Linux / FreeBSD system?
TELNET (TELetype NETwork) is a network protocol used on the Internet or local area network LAN connections.
The telnetd program (telnet server) is a server which supports the DARPA telnet interactive communication protocol. Telnetd is normally invoked by the internet server inetd or xinetd for requests to connect to the telnet port as indicated by the /etc/services file. Usaually telnet listen on port TCP port 23.
Telnet in is insecure protocol and it is recommended that you use ssh server. But some time you really need telnet then first install telnet server as according to version of Linux distribution.
The telnetd program (telnet server) is a server which supports the DARPA telnet interactive communication protocol. Telnetd is normally invoked by the internet server inetd or xinetd for requests to connect to the telnet port as indicated by the /etc/services file. Usaually telnet listen on port TCP port 23.
Telnet in is insecure protocol and it is recommended that you use ssh server. But some time you really need telnet then first install telnet server as according to version of Linux distribution.
Debain/Ubuntu Linux user type the following command:
# apt-get install telnetd
OR
$ sudo apt-get install telnetdFedora Linux user the following command:
# yum install telnet-server telnetRed Hat enterprise Linux user type the following command:
up2date telnet-server telnetFreeBSD user type the following command:
No need to install new (telnet server) package, it is installed by default (/usr/libexec/telnetd)
Configure telnet server (turn on telnet server)
Again each distribution has its own method to turn on or off telnet service; same applies to telnet UNIX/Linux server.
If you are using Red Hat / Fedora Linux
The configuration file for telnet is /etc/xinetd.d/telnet. To enable telnet server you need to open this file and make sure disable = no read as disable = yes.
Alternately,
# chkconfig telnet onTo start telnet server type command:
# /etc/init.d/xinetd restartIf you are using Debian Linux
The configuration file for telnet is /etc/inetd.conf. By default it is enabled when you install telnet server. To start telnet server type command:
# /etc/init.d/inetd restartIf you are using FreeBSD
The configuration file for telnet is /etc/inetd.conf. Open file using vi text editor and uncomment line:
# vi /etc/inetd.conf
Make sure commented line:
#telnet stream tcp nowait root /usr/libexec/telnetd telnetdRead as follows:
telnet stream tcp nowait root /usr/libexec/telnetd telnetdSave and close the file. Start telnet service:
Enable inetd service so that telnet get loaded:
# vi /etc/rc.confAppend/add following line to configuration file:
inetd_enable="YES"Save and close the file, Rsstart telnet via inetd service:
# /etc/rc.d/inetd restart
Telnet to server (How do I use telnet client?)
You should now be able to telnet to the server from Windows or Linux desktop system. Type the following command to connect to Telnet server:telnet server-ip-address
telnet 192.168.1.5
Saturday, August 13, 2011
Getting kernal parameters and rebuilding kernel in Linux/Unix systems
Nice overview of Linux kernel is provided in the Performance Tuning for Linux An Introduction to Kernels Linux Kernel Architecture. Here is an extended quote from sample chapter:
Let’s begin this section by discussing the architecture of the Linux kernel, including responsibilities of the kernel, its organization and modules, services of the kernel, and process management.
Kernel Responsibilities
The kernel (also called the operating system) has two major responsibilities:
Some operating systems allow applications to directly access hardware components, although this capability is very uncommon nowadays. UNIX-like operating systems hide all the low-level hardware details from an application. If an application wants to make use of a hardware resource, it must make a request to the operating system. The operating system then evaluates the request and interacts with the hardware component on behalf of the application, but only if it’s valid. To enforce this kind of scheme, the operating system needs to depend on hardware capabilities that forbid applications to directly interact with them.
Organization and Modules
Like many other UNIX-like operating systems, the Linux kernel is monolithic. This means that even though Linux is divided into subsystems that control various components of the system (such as memory management and process management), all of these subsystems are tightly integrated to form the whole kernel. In contrast, microkernel operating systems provide bare, minimal functionality, and all other operating system layers are performed on top of microkernels as processes. Microkernel operating systems are generally slower due to message passing between the various layers. However, microkernel operating systems can be extended very easily.
Linux kernels can be extended by modules. A module is a kernel feature that provides the benefits of a microkernel without a penalty. A module is an object that can be linked to the kernel at runtime.
Using Kernel Services
The kernel provides a set of interfaces for applications running in user mode to interact with the system. These interfaces, also known as system calls, give applications access to hardware and other kernel resources. System calls not only provide applications with abstracted hardware, but also ensure security and stability.
Most applications do not use system calls directly. Instead, they are programmed to an application programming interface (API). It is important to note that there is no relation between the API and system calls. APIs are provided as part of libraries for applications to make use of. These APIs are generally implemented through the use of one or more system calls.
/proc File System—External Performance View
The /proc file system provides the user with a view of internal kernel data structures. It also lets you look at and change some of the kernel internal data structures, thereby changing the kernal’s behavior. The /proc file system provides an easy way to fine-tune system resources to improve the performance not only of applications but of the overall system.
/proc is a virtual file system that is created dynamically by the kernel to provide data. It is organized into various directories. Each of these directories corresponds to tunables for a given subsystem. Appendix A explains in detail how to use the /proc file system to fine-tune your system.
Another essential of the Linux system is memory management. In the next section, we’ll cover five aspects of how Linux handles this management.
Memory Management
The various aspects of memory management in Linux include address space, physical memory, memory mapping, paging, and swapping.
Address Space. One of the advantages of virtual memory is that each process thinks it has all the address space it needs. The virtual memory can be many times larger than the physical memory in the system. Each process in the system has its own virtual address space. These virtual address spaces are completely separate from each other. A process running one application cannot affect another, and the applications are protected from each other. The virtual address space is mapped to physical memory by the operating system. From an application point of view, this address space is a flat linear address space. The kernel, however, treats the user virtual address space very differently.
The linear address space is divided into two parts: user address space and kernel address space. The user address space cannot change every time a context switch occurs and the kernel address space remains constant. How much space is allocated for user space and kernel space depends mainly on whether the system is a 32-bit or 64-bit architecture. For example, x86 is a 32-bit architecture and supports only a 4GB address space. Out of this 4GB, 3GB is reserved for user space and 1GB is reserved for the kernel. The location of the split is determined by the PAGE_OFFSET kernel configuration variable.
Physical Memory Linux uses an architecture-independent way of describing physical memory in order to support various architectures.
Physical memory can be arranged into banks, with each bank being a particular distance from the processor. This type of memory arrangement is becoming very common, with more machines employing NUMA (Nonuniform Memory Access) technology. Linux VM represents this arrangement as a node. Each node is divided into a number of blocks called zones that represent ranges within memory. There are three different zones: ZONE_DMA, ZONE_NORMAL, and ZONE_HIGHMEM. For example, x86 has the following zones:
ZONE_ DMA First 16MB of memory
ZONE_ NORMAL 16MB – 896MB
ZONE_ HIGHMEM 896MB – end
Each zone has its own use. Some of the legacy ISA devices have restrictions on where they can perform I/O from and to. ZONE_DMA addresses those requirements.
ZONE_NORMAL is used for all kernel operations and allocations. It is extremely crucial for system performance.
ZONE_ HIGHMEM is the rest of the memory in the system. It’s important to note that ZONE_HIGHMEM cannot be used for kernel allocations and data structures—it can only be used for user data.
Memory Mapping While looking at how kernel memory is mapped, we will use x86 as an example for better understanding. As mentioned earlier, the kernel has only 1GB of virtual address space for its use. The other 3GB is reserved for the kernel. The kernel maps the physical memory in ZONE_DMA and ZONE_NORMAL directly to its address space. This means that the first 896MB of physical memory in the system is mapped to the kernel’s virtual address space, which leaves only 128MB of virtual address space. This 128MB of virtual space is used for operations such as vmalloc and kmap.
This mapping scheme works well as long as physical memory sizes are small (less than 1GB). However, these days, all servers support tens of gigabytes of memory. Intel has added PAE (Physical Address Extension) to its Pentium processors to support up to 64GB of physical memory. Because of the preceding memory mapping, handling physical memories in tens of gigabytes is a major source of problems for x86 Linux. The Linux kernel handles high memory (all memory about 896MB) as follows: When the Linux kernel needs to address a page in high memory, it maps that page into a small virtual address space (kmap) window, operates on that page, and unmaps the page. The 64-bit architectures do not have this problem because their address space is huge.
Paging Virtual memory is implemented in many ways, but the most effective way is hardware-based. Virtual address space is divided into fixed-size chunks called pages. Virtual memory references are translated into addresses in physical memory using page tables. To support various architectures and page sizes, Linux uses a three-level paging mechanism. The three types of page tables are as follows:
The replacement policy is one of the most critical aspects of the paging system. Linux 2.6 fixed various problems surrounding the page selection and replacement that were present in previous versions of Linux.
Swapping Swapping is the moving of an entire process to and from secondary storage when the main memory is low. Many modern operating systems, including Linux, do not use this approach, mainly because context switches are very expensive. Instead, they use paging. In Linux, swapping is performed at the page level rather than at the process level. The main advantage of swapping is that it expands the process address space that is usable by a process. As the kernel needs to free up memory to make room for new pages, it may need to discard some of the less frequently used or unused pages. Some of the pages cannot be freed up easily because they are not backed by disks. Instead, they have to be copied to a backing store (swap area) and need to be read back from the backing store when needed. One major disadvantage of swapping is speed. Generally, disks are very slow, so swapping should be eliminated whenever possible.
Let’s begin this section by discussing the architecture of the Linux kernel, including responsibilities of the kernel, its organization and modules, services of the kernel, and process management.
Kernel Responsibilities
The kernel (also called the operating system) has two major responsibilities:
- To interact with and control the system’s hardware components
- To provide an environment in which applications can run
Some operating systems allow applications to directly access hardware components, although this capability is very uncommon nowadays. UNIX-like operating systems hide all the low-level hardware details from an application. If an application wants to make use of a hardware resource, it must make a request to the operating system. The operating system then evaluates the request and interacts with the hardware component on behalf of the application, but only if it’s valid. To enforce this kind of scheme, the operating system needs to depend on hardware capabilities that forbid applications to directly interact with them.
Organization and Modules
Like many other UNIX-like operating systems, the Linux kernel is monolithic. This means that even though Linux is divided into subsystems that control various components of the system (such as memory management and process management), all of these subsystems are tightly integrated to form the whole kernel. In contrast, microkernel operating systems provide bare, minimal functionality, and all other operating system layers are performed on top of microkernels as processes. Microkernel operating systems are generally slower due to message passing between the various layers. However, microkernel operating systems can be extended very easily.
Linux kernels can be extended by modules. A module is a kernel feature that provides the benefits of a microkernel without a penalty. A module is an object that can be linked to the kernel at runtime.
Using Kernel Services
The kernel provides a set of interfaces for applications running in user mode to interact with the system. These interfaces, also known as system calls, give applications access to hardware and other kernel resources. System calls not only provide applications with abstracted hardware, but also ensure security and stability.
Most applications do not use system calls directly. Instead, they are programmed to an application programming interface (API). It is important to note that there is no relation between the API and system calls. APIs are provided as part of libraries for applications to make use of. These APIs are generally implemented through the use of one or more system calls.
/proc File System—External Performance View
The /proc file system provides the user with a view of internal kernel data structures. It also lets you look at and change some of the kernel internal data structures, thereby changing the kernal’s behavior. The /proc file system provides an easy way to fine-tune system resources to improve the performance not only of applications but of the overall system.
/proc is a virtual file system that is created dynamically by the kernel to provide data. It is organized into various directories. Each of these directories corresponds to tunables for a given subsystem. Appendix A explains in detail how to use the /proc file system to fine-tune your system.
Another essential of the Linux system is memory management. In the next section, we’ll cover five aspects of how Linux handles this management.
Memory Management
The various aspects of memory management in Linux include address space, physical memory, memory mapping, paging, and swapping.
Address Space. One of the advantages of virtual memory is that each process thinks it has all the address space it needs. The virtual memory can be many times larger than the physical memory in the system. Each process in the system has its own virtual address space. These virtual address spaces are completely separate from each other. A process running one application cannot affect another, and the applications are protected from each other. The virtual address space is mapped to physical memory by the operating system. From an application point of view, this address space is a flat linear address space. The kernel, however, treats the user virtual address space very differently.
The linear address space is divided into two parts: user address space and kernel address space. The user address space cannot change every time a context switch occurs and the kernel address space remains constant. How much space is allocated for user space and kernel space depends mainly on whether the system is a 32-bit or 64-bit architecture. For example, x86 is a 32-bit architecture and supports only a 4GB address space. Out of this 4GB, 3GB is reserved for user space and 1GB is reserved for the kernel. The location of the split is determined by the PAGE_OFFSET kernel configuration variable.
Physical Memory Linux uses an architecture-independent way of describing physical memory in order to support various architectures.
Physical memory can be arranged into banks, with each bank being a particular distance from the processor. This type of memory arrangement is becoming very common, with more machines employing NUMA (Nonuniform Memory Access) technology. Linux VM represents this arrangement as a node. Each node is divided into a number of blocks called zones that represent ranges within memory. There are three different zones: ZONE_DMA, ZONE_NORMAL, and ZONE_HIGHMEM. For example, x86 has the following zones:
ZONE_ DMA First 16MB of memory
ZONE_ NORMAL 16MB – 896MB
ZONE_ HIGHMEM 896MB – end
Each zone has its own use. Some of the legacy ISA devices have restrictions on where they can perform I/O from and to. ZONE_DMA addresses those requirements.
ZONE_NORMAL is used for all kernel operations and allocations. It is extremely crucial for system performance.
ZONE_ HIGHMEM is the rest of the memory in the system. It’s important to note that ZONE_HIGHMEM cannot be used for kernel allocations and data structures—it can only be used for user data.
Memory Mapping While looking at how kernel memory is mapped, we will use x86 as an example for better understanding. As mentioned earlier, the kernel has only 1GB of virtual address space for its use. The other 3GB is reserved for the kernel. The kernel maps the physical memory in ZONE_DMA and ZONE_NORMAL directly to its address space. This means that the first 896MB of physical memory in the system is mapped to the kernel’s virtual address space, which leaves only 128MB of virtual address space. This 128MB of virtual space is used for operations such as vmalloc and kmap.
This mapping scheme works well as long as physical memory sizes are small (less than 1GB). However, these days, all servers support tens of gigabytes of memory. Intel has added PAE (Physical Address Extension) to its Pentium processors to support up to 64GB of physical memory. Because of the preceding memory mapping, handling physical memories in tens of gigabytes is a major source of problems for x86 Linux. The Linux kernel handles high memory (all memory about 896MB) as follows: When the Linux kernel needs to address a page in high memory, it maps that page into a small virtual address space (kmap) window, operates on that page, and unmaps the page. The 64-bit architectures do not have this problem because their address space is huge.
Paging Virtual memory is implemented in many ways, but the most effective way is hardware-based. Virtual address space is divided into fixed-size chunks called pages. Virtual memory references are translated into addresses in physical memory using page tables. To support various architectures and page sizes, Linux uses a three-level paging mechanism. The three types of page tables are as follows:
- Page Global Directory (PGD)
- Page Middle Directory (PMD)
- Page Table (PTE)
The replacement policy is one of the most critical aspects of the paging system. Linux 2.6 fixed various problems surrounding the page selection and replacement that were present in previous versions of Linux.
Swapping Swapping is the moving of an entire process to and from secondary storage when the main memory is low. Many modern operating systems, including Linux, do not use this approach, mainly because context switches are very expensive. Instead, they use paging. In Linux, swapping is performed at the page level rather than at the process level. The main advantage of swapping is that it expands the process address space that is usable by a process. As the kernel needs to free up memory to make room for new pages, it may need to discard some of the less frequently used or unused pages. Some of the pages cannot be freed up easily because they are not backed by disks. Instead, they have to be copied to a backing store (swap area) and need to be read back from the backing store when needed. One major disadvantage of swapping is speed. Generally, disks are very slow, so swapping should be eliminated whenever possible.
HP-UX | SOLARIS | |||
| Startup script | /etc/rc | /sbin/rc | /etc/rc.d/rc | /etc/init.d |
| Kernel | /usr/lib/boot/unix_up | /stand/vmunix | /boot/vmlinuz | /kernel/genunix |
| Kernel Parameters | lsattr -E -l sys0 | sysdef kmtune kmsystem | sysctl -a | sysdef -i |
| Reconfigure the kernel | chdev -l sys0 -a | cd /stand/build /usr/lbin/sysadm/system_prep -v -s system vi system mk_kernel -s system cd /stand mv system system.prev mv vmunix vmunix.prev mv dlkm dlkm.prev mv /stand/build/system system kmupdate /stand/build/vmunix_test | cd /usr/src/linux make mrproper make menuconfig make dep make clean make bzImage make install make modules make modules_install cp arch/i386/boot/bzImage /boot/vmlinuz-2.2.16 | vi /etc/system reboot |
| List modules | genkex | kmadmin -s | lsmod | modinfo |
| Load module | kmadmin -L | insmod | modload | |
| Unload module | kmadmin -U | rmmod | modunload | |
| Initialize system | install_assist | set_parms initial | netconf | sys-unconfig |
| Physical RAM | bootinfo -r | grep -i Physical /var/adm/syslog/syslog.log | free | prtconf |
| Kernel Bits | bootinfo -K | getconf KERNEL_BITS | getconf LONG_BIT | isainfo -kv |
| Crash utility | crash | adb | lcrash | crash |
| Trace System Calls | syscalls | tusc | strace | truss |
| Machine model | uname -m bootinfo -m | model uname -m | uname -m | uname -imp |
| OS Level | oslevel | uname -r | uname -r | uname -r |
| Run Level | who -r | who -r | runlevel | who -r |
| Core dump files | /var/adm/ras | /var/adm/crash | /var/crash/`uname -n` | |
| Boot single user | Key on service mode/F4 Boot from CD/Tape Select Maintenance Limited function Shell | >boot Interact with IPL ? Y ISL>hpux -iS | {lilo} control-x linux S {grub} c kernel vmlinuz-2.4.9-13 single ro root=/dev/hda8 initrd /initrd-2.4.9-13.img boot | ok boot -s |
| Maintenance mode | >boot Interact with IPL ? Y ISL>hpux -lm | ok boot -as | ||
| Interrupt Key | control-B | Stop-A | ||
| Return to console | co | ok go | ||
| Timezone Management | /etc/environment /etc/profile | /etc/TIMEZONE | /etc/sysconfig/clock | /etc/TIMEZONE /etc/default/init |
| NTP Daemon | /etc/ntp.conf startsrc -s xntpd | /etc/rc.config.d/netdaemons /sbin/init.d/xntpd | /etc/ntp.conf /etc/rc.d/init.d/xntpd | /etc/inet/ntp.conf /etc/init.d/xntpd |
DISK/LVM Commands for Unix/Linux
In the olden days computer disks were small compared to the data set sizes that were needed. A solution is to make several physical disks appear virtually (or logically) as a single much larger disk. A large filesystem could then be created on that virtual disk.
Later hard disk sizes grew large enough that it made sense to do the opposite: make one physical disk appear as several virtual disks. Each virtual disk holds a filesystem independently of the others. Today such virtual disks are called disk "partitions".
Now we have come full circle. Large data warehouse applications require very large filesystems to hold the database data files. To support this sort of application the old idea of combining several disks into one has been resurrected. Novell Netware supported this feature since the 1990s. The physical disk (or selected disk partitions) are formatted to be "physical volume segments". All added physical volume segments become part of a single large virtual disk. The administrator can then create logical "volumes", that is, a filesystem. The exciting part is that if some volume is low on space, you can extend the virtual disk by adding another physical volume segment to it, and then increase the (logical) volume's size. This operation is fast and doesn't disturb the existing data or other partitions (or volumes)!
The modern Unix (and Linux) version of this idea is called "Logical Volume Management" (or "LVM"). LVM allows the administrator to
Linux also supports software RAID, which, like LVM, can be used to provide disk striping. The two systems are independent of each other. So you can use RAID to provide striping and use that RAID volume as a physical volume for LVM. There is no reason to use both software RAID and LVM, although it can be done. However it does make good sense to use hardware RAID and LVM together.
Later hard disk sizes grew large enough that it made sense to do the opposite: make one physical disk appear as several virtual disks. Each virtual disk holds a filesystem independently of the others. Today such virtual disks are called disk "partitions".
Now we have come full circle. Large data warehouse applications require very large filesystems to hold the database data files. To support this sort of application the old idea of combining several disks into one has been resurrected. Novell Netware supported this feature since the 1990s. The physical disk (or selected disk partitions) are formatted to be "physical volume segments". All added physical volume segments become part of a single large virtual disk. The administrator can then create logical "volumes", that is, a filesystem. The exciting part is that if some volume is low on space, you can extend the virtual disk by adding another physical volume segment to it, and then increase the (logical) volume's size. This operation is fast and doesn't disturb the existing data or other partitions (or volumes)!
The modern Unix (and Linux) version of this idea is called "Logical Volume Management" (or "LVM"). LVM allows the administrator to
- use and allocate disk space more efficiently and flexibly
- move logical volumes between different physical devices
- have very large logical volumes span a number of physical devices
- take snapshots of whole filesystems easily, allowing on-line backup of those filesystems
- replace on-line drives without interrupting services
Linux also supports software RAID, which, like LVM, can be used to provide disk striping. The two systems are independent of each other. So you can use RAID to provide striping and use that RAID volume as a physical volume for LVM. There is no reason to use both software RAID and LVM, although it can be done. However it does make good sense to use hardware RAID and LVM together.
HP-UX:Disk &Filesystem | SOLARIS | |||
| Filesystem table | /etc/filesystems | /etc/fstab | /etc/fstab | /etc/vfstab |
| Free disk blocks | df -k | bdf | df -k | df -k |
| Device listing | lsdev -C | /sbin/ioscan | cat /proc/devices | sysdef |
| Disk information | bootinfo -s hdisk# | diskinfo /dev/rdsk/c#t#d# | cat /proc/scsi/scsi0/sda/model | format -d c#t#d# format>current format>inquiry |
| Disk Label | lspv -l hdisk# | pvdisplay -v /dev/dsk/C#t#d# | fdisk -l | prtvtoc |
| LVM Concepts | Partition | logical extents | logical extents | sub disk |
| Volume | logical volume | logical volume | Volume | |
| Plex | ||||
| Volume group | volume group | volume group | disk group | |
| Journal Filesystem type | jfs | vxfs | ext3 reiserfs | vxfs |
| Default volume group | /dev/rootvg | /dev/vg00 | /dev/vx/dsk/rootdg | |
| Display volume group | lsvg -l rootvg | vgdisplay -v vg00 | vgdisplay -v | vxprint -l -g rootdg |
| Modify physical volume | chpv | pvchange | pvchange | |
| Prepare physical disk | mkdev -c disk -l hdisk# | pvcreate | pvcreate | vxdiskadd |
| List physical volume | lspv | pvdisplay | pvdisplay | vxprint -dl |
| Remove disk from volume group | reducevg | vgreduce | vgreduce | vxdg rmdisk |
| Move logical volumes to another physical volumes | migratepv | pvmove | pvmove | vxassist move |
| Create volume group | mkvg | vgcreate | vgcreate | vxdg init |
| Remove volume group | vgremove | vgremove | ||
| Volume group availability | chvg varyonvg varyoffvg | vgchange | vgchange | |
| Restore volume group | vgcfgrestore | vgcfgrestore | ||
| Exports volume group | exportvg | vgexport | vgexport | vxdg deport |
| Imports volume group | importvg | vgimport | vgimport | vxdg import |
| Volume group listing | lsvg | vgscan | vgscan | |
| Change logical volume characteristics | chlv | lvchange | lvchange | vxedit set |
| List logical volume | lslv | lvdisplay | lvdisplay | vxprint -vl |
| Make logical volume | mklv | lvcreate | lvcreate | vxassist make |
| Extend logical volume | extendlv | lvextend | lvextend | vxassist growto |
| Reduce logical volume | AIX reduce LV | lvreduce | lvreduce | vxassist shrinkto |
| Remove logical volume | rmlv | lvremove | lvremove | vxedit rm |
| Prepare boot volumes | bootlist -m normal | lvlnboot | lilo | vxbootsetup |
| Remove boot volumes | lvrmboot | |||
| Extend File system | chfs -a size=# /mt | extendfs /dev/vg00/lvol8 fsadm -F vxfs -b {LE * 1024} /mt | resize2fs resize_reiserfs | vxva mkfs -M |
| Reduce/Split mirrors | rmlvcopy | lvsplit | lvsplit | |
| Merge mirrors | lvmerge | lvmerge | ||
| Create mirrors | mklv -c 2 | lvcreate -m 1 | vxassist mirror | |
| Add mirrors | mklvcopy lv 2 | lvextend -m 1 | ||
| Create striped volumes | mklv -u 3 -S 64K | lvcreate -i 3 -I 64 | lvcreate -i 3 -I 64 | vxassist make vol 100mb layout=raid5 |
| System recovery tape | mksysb -i /dev/rmt0 | /opt/ignite/bin/make_recovery | ||
| Backup | savevg -i rootvg | fbackup | tar cvf /dev/rst0 / | ufsdump |
| Restore | restvg | frecover | tar xvf /dev/rst0 | ufsrestore |
Wednesday, August 10, 2011
Unix/Linux network related information
Some times you may need to find/modify network related information in Linux/Unix systems. You can find most of the network related information from following table :
Network IP configuration :
AIX : lsattr -E -l inet0
HP-UX : /etc/rc.config.d/netconf
LINUX(RedHat): /etc/sysconfig/network-scripts/
Solaris : /etc/hostname.*
/etc/inet/*
/etc/defaultrouter
Hosts IP addresses :
AIX : /etc/hosts
HP-UX : /etc/hosts
LINUX(RedHat): /etc/hosts
Solaris : /etc/inet/hosts
Name service switch :
AIX : /etc/netsvc.conf
HP-UX : /etc/nsswitch.conf
LINUX(RedHat): /etc/nsswitch.conf
Solaris : /etc/nsswitch.conf
Network parameters :
AIX : no -a
HP-UX : ndd -h
LINUX(RedHat): sysctl -a | grep net
Solaris : ndd /dev/[tcp|ip] ?
Routing daemon :
AIX : gated
HP-UX : gated
LINUX(RedHat): routed
Solaris : in.routed
NIC Configurations :
AIX : ifconfig -a
HP-UX : lanscan -v
LINUX(RedHat): ifconfig -a
Solaris : ifconfig -a
Secondary IP Address :
AIX : ifconfig en0 alias IP
HP-UX : ifconfig lan0:1 IP
LINUX(RedHat): modprobe ip_alias
ifconfig eth0:1 IP
Solaris : ifconfig hme0:1 IP up
Login prompt :
AIX : HERALD @
/etc/security/login.cfg
HP-UX : telnetd -b /etc/issue
LINUX(RedHat): /etc/issue
Solaris : BANNER @
/etc/default/telnetd
Increase the # of pseudo-terminals :
AIX : odmget -q "attribute=num and uniquetype=pty/pty/pty" PdAt | sed
"s/0-64/0-512/" |
odmchange -q "attribute=num and uniquetype=pty/pty/pty" -o PdAt
Network IP configuration :
AIX : lsattr -E -l inet0
HP-UX : /etc/rc.config.d/netconf
LINUX(RedHat): /etc/sysconfig/network-scripts/
Solaris : /etc/hostname.*
/etc/inet/*
/etc/defaultrouter
Hosts IP addresses :
AIX : /etc/hosts
HP-UX : /etc/hosts
LINUX(RedHat): /etc/hosts
Solaris : /etc/inet/hosts
Name service switch :
AIX : /etc/netsvc.conf
HP-UX : /etc/nsswitch.conf
LINUX(RedHat): /etc/nsswitch.conf
Solaris : /etc/nsswitch.conf
Network parameters :
AIX : no -a
HP-UX : ndd -h
LINUX(RedHat): sysctl -a | grep net
Solaris : ndd /dev/[tcp|ip] ?
Routing daemon :
AIX : gated
HP-UX : gated
LINUX(RedHat): routed
Solaris : in.routed
NIC Configurations :
AIX : ifconfig -a
HP-UX : lanscan -v
LINUX(RedHat): ifconfig -a
Solaris : ifconfig -a
Secondary IP Address :
AIX : ifconfig en0 alias IP
HP-UX : ifconfig lan0:1 IP
LINUX(RedHat): modprobe ip_alias
ifconfig eth0:1 IP
Solaris : ifconfig hme0:1 IP up
Login prompt :
AIX : HERALD @
/etc/security/login.cfg
HP-UX : telnetd -b /etc/issue
LINUX(RedHat): /etc/issue
Solaris : BANNER @
/etc/default/telnetd
Increase the # of pseudo-terminals :
AIX : odmget -q "attribute=num and uniquetype=pty/pty/pty" PdAt | sed
"s/0-64/0-512/" |
odmchange -q "attribute=num and uniquetype=pty/pty/pty" -o PdAt
chdev -l pty0 -anum=256 -P
reboot
HP-UX : rebuild your kernel with these new values NPTY=#
NSTRPY=#
reboot
insf -d ptys -n #
insf -d ptym -n #
insf -d pts -s # -e -v
LINUX(RedHat): cd /dev
./MAKEDEV -v pty
Solaris : {/etc/system}
set pt_cnt = # {SYSV}
set npty = # {BSD}
{/etc/iu.ap}
ptsl 0 # ldterm ttcompat
halt
boot -r
Maximum # of ptys :
AIX : 512
HP-UX : {MAXUSERS}
LINUX(RedHat): 256
Solaris : 176 {BSD}
3000 {SYSV}
Remote Shell :
AIX : remsh
rsh
HP-UX : remsh
LINUX(RedHat): rsh
Solaris : rsh
YP/NIS service binder :
AIX : /usr/lib/netsvc/yp/ypbind
HP-UX : /usr/lib/netsvc/yp/ypbind
LINUX(RedHat): /sbin/ypbind
Solaris : /usr/lib/netsvc/yp/ypbind
General commands for Unix and Linux
Some times you need to get some general information (But valuable) when working with Unix/Linux systems.
Ex : Performance information, Error logs
Ex : Performance information, Error logs
| Unique host ID | hostid | uname -i | hostid | hostid |
| Administrator | smit | sam | linuxconf | admintool |
| Performance monitor | top monitor | top glance | top | top |
| System activity reporter | sar | sar | sar {sysstat} | sar |
| Virtual Memory statistics | vmstat | vmstat | vmstat | vmstat |
| I/O statistics | iostat | iostat | iostat {sysstat} | iostat |
| Error logs | alog -o -t boot errpt | dmesg | dmesg | dmesg |
| Physical RAM | 1TB | 4TB | 64 GB {>2.3.24} | 16TB |
| Shared Memory | 2.75GB | 8TB | sysctl kernel.shmmax | |
| Process Data Space | 2GB | 4GB | 900 MB | |
| Swap device | /dev/hd6 | /dev/vg00/lvol2 | /dev/sda2 | /dev/vx/dsk/swapvol |
| Swap file type | /etc/swapspaces | swap | partition type 82 | swap |
| Display swap size | lsps -a | swapinfo -a | free | swap -l |
| Activate Swap | swapon -a | swapon -a | swapon -a | swap -a |
Unix/Linux user account related information
Most of the Unix/Linux systems have similar commands and files to modify user and group related information. But there are very small differences like below :
Unix and Linux directory Mappings
Unix and Linux has same directory structure(can have small deference). But Unix and Linux directory Mappings are not the same. Following are the default directory mappings for Unix and Linux
Displaying the number of CPU processors in UNIX
You need to have special command for each dialect of UNIX to display CPU information. Knowing the number of CPUs is very important to the Oracle DBA because it shows the number of parallel query processes that can be concurrently executing on the UNIX server. Table 2-2 shows the common commands for each major dialect.
Linux :
cat /proc/cpuinfo|grep processor|wc –l
Solaris :
psrinfo -v|grep "Status of processor"|wc –l
AIX :
lsdev -C|grep Process|wc –l
HP/UX :
ioscan -C processor | grep processor | wc -l
Linux :
cat /proc/cpuinfo|grep processor|wc –l
Solaris :
psrinfo -v|grep "Status of processor"|wc –l
AIX :
lsdev -C|grep Process|wc –l
HP/UX :
ioscan -C processor | grep processor | wc -l
Subscribe to:
Posts (Atom)
