 |
» |
|
|
|
|
|
|
|
|
|
Patch Name: PHKL_25999
Patch Description: s700_800 11.00 syscall, msem_lock, umask cumulative patch
Creation Date: 02/01/08
Post Date: 02/01/14
Warning: 03/06/23 - This Critical Warning has been issued by HP.
- With PHKL_27089 or superseding patches installed, customers
have experienced a severe performance problem with the kernel
scheduling algorithm within the idle() loop of the Fair
Share Scheduler (FSS) used by the Process Resource Manager
(PRM) and WorkLoad Manager (WLM) applications. If either
application is enabled on a system, system performance
degrades dramatically in some cases.
- Performance degradation of 3 to 4 times for a single job has
been observed. Also, ServiceGuard nodes have experienced a
TOC due to this behavior.
- The problem has only been seen at customer sites on high end
systems containing more than 16 CPUs. However due to the
nature of the problem, it may impact any size system
especially a system with a heavy load on a few processors
with many other processors idle.
- The behavior increases with the number of processors that
are currently idle. Therefore, a system that continuously
keeps all CPUs busy may not observe the behavior.
- Additional information on this issue may be found in SR
8606311958 (JAGae74778).
- This behavior is also exhibited with superseding patches
PHKL_27351, PHKL_27510, PHKL_27813, PHKL_27770, PHKL_28152,
and PHKL_28202.
- The source of the problem was actually introduced in
PHKL_21111. Therefore it is possible that any of these
patches is exposed to this behavior: PHKL_21111, PHKL_21832,
PHKL_23180, PHKL_23408, PHKL_23617, PHKL_24502, PHKL_24753,
PHKL_24734, PHKL_24943, PHKL_25475, PHKL_25999, PHKL_26059,
PHKL_27089, PHKL_27351, PHKL_27510, PHKL_27813, PHKL_27770,
PHKL_28152, and PHKL_28202. As a result, HP is issuing Patch
Warnings for all these patches. However, customers have only
experienced the problem on PHKL_27089 and later. This is
believed to be due to the recompilation of the files
containing the original change.
- To verify if a system experiencing performance problems is
due to this behavior, PRM and WLM can be temporarily
disabled by issuing the following commands as root:
PRM: /opt/prm/bin/prmconfig -r
WLM: /sbin/init.d/wlm stop
- If disabling PRM and WLM verified that the system is the
experiencing the behavior, then HP recommends removing these
patches from systems and install PHKL_24502 to use either PRM
or WLM.
- PHKL_24502 also contains the code path that has been
demonstrated to lead to this behavior. However, PHKL_24502
has not been shown to cause this same behavior with PRM or
WLM on customer systems.
Hardware Platforms - OS Releases:
s700: 11.00
s800: 11.00
Products: N/A
Filesets:
OS-Core.CORE-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP
ProgSupport.C-INC,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP
Automatic Reboot?: Yes
Status: General Superseded With Warnings
Critical:
Yes
PHKL_25999: PANIC HANG
PHKL_22796: PANIC
PHKL_25475: PANIC CORRUPTION HANG
PHKL_24943: HANG
PHKL_24753: PANIC HANG
PHKL_23955: OTHER
Poor performance due to mutex contention on
large multi-threaded applications.
PHKL_23002: CORRUPTION PANIC HANG
PHKL_22940: HANG
thread hang
PHKL_20202: PANIC
This patch must be applied for nfs/tcp to function.
PHKL_24733: HANG
PHKL_23842: OTHER
False ServiceGuard failovers after long dispatch
latency in the kernel.
PHKL_23407: OTHER
Hung, Unkillable process
PHKL_20625: PANIC
PHKL_23617: OTHER
False ServiceGuard failovers due to long dispatch
latency.
PHKL_23408: OTHER
Hung, unkillable process
PHKL_23180: PANIC
PHKL_20883: HANG
PHKL_20659: PANIC
PHKL_20399: HANG
PHKL_22517: PANIC
PHKL_21608: PANIC
PHKL_20315: PANIC HANG
PHKL_14119: OTHER
Binary compatibility was not maintained for 32 bit
applications running on 64 bit systems.
Category Tags:
defect_repair hardware_enablement enhancement
general_release critical panic halts_system corruption
Path Name: /hp-ux_patches/s700_800/11.X/PHKL_25999
Symptoms:
PHKL_25999:
( SR:8606230577 CR:JAGad99627 )
Under extreme loads, like those used during HP internal
kernel stress testing, and even then very infrequently, the
kernel may panic with a data page fault in the signal
routines for multi-threaded processes. The stack of the
faulting thread ends with:
<data page fault trap>
pm_signalx()
pm_psignalx()
psignalx()
kill1()
kill()
syscall()
( SR:8606186056 CR:JAGad55261 )
Software providers may observe performance deficiencies in
applications which heavily use shared mutexes. Performance
of a PTHREAD_PROCESS_SHARED mutex unlock operation is slower
than that of a PTHREAD_PROCESS_PRIVATE mutex, even in the
non-contended (i.e., no waiters) case.
( SR:8606230581 CR:JAGad99631 )
Thread cancellation sometimes, but rarely, will fail to make
the target thread exit. Applications which use thread
cancellation may misbehave when this happens. Sometimes
they may hang waiting for the target thread to exit.
( SR:8606221319 CR:JAGad90453 )
While running iCOD and PRM on the same system, PRM groups
are incorrectly allowed to exceed their CPU entitlement.
This is a problem when using the PRM capping feature.
( SR:8606228779 CR:JAGad97833 )
Enhancement to increase the size of the process command line
stored in the kernel.
PHKL_23226:
( SR: 8606175710 CR: JAGad44950 )
umask(1) may incorrectly set file permission bits.
PHKL_22796:
(SR:8606170084 CR:JAGad39348)
The following lightweight system calls will cause
the system to crash if a badly written user level
program tries to branch beyond the allowed address
space.
lw_lwp_setprivate, lw_lwp_getprivate, lw_get_thread_times,
lw_lf_send, lw_lf_next_scn, cnx_lw_pmon_read, lw_mcas_util,
and lw_nosys.
PHKL_20245:
( SR: 8606102049 CR: JAGab67439 )
Desc: msem_lock() call occasionally fails w/EINVAL
One customer finds that msem_lock() occasionally fails and
errno is set to EFAULT. If the exactly same msem_lock()
call is executed again, it works.
PHKL_20236:
( SR: 4701409169 DTS: JAGaa12229 )
__lw_get_thread_times reports incorrect times on V-Class
systems. Most of the time it reports correctly but on
occasion it will return an erroneous system time value.
PHKL_25475:
( SR:8606221043 CR:JAGad90179 )
The kernel build may fail during, or after, installation
of patch PHKL_23002 or a superseding patch with the error:
cpp: "/usr/conf/space.h.d/core-hpux.h", line 27: error 4036:
Can't open include file 'sys/spinlock.h'.
*** Error exit code 1
( SR:8606220050 CR:JAGad89191 )
With PHKL_23955 or a superseding patch installed, an
interruptible system hang on a uniprocessor system or a
thread hang and/or performance degradation on a
multiprocessor system may occur.
( SR:8606199334 CR:JAGad68521 )
When the system is running an application with many threads
sleeping with short timer expirations, it may panic with a
Data Page fault.
Following is a typical stack trace footprint that exhibits
the problem:
0) panic+0x14
1) report_trap_or_int_and_panic+0x84
2) interrupt+0x1d4
3) ihandler+0x928
+------------- TRAP ----------------------------
| Trap type 15 in KERNEL at 0x185ce0 (pm_setrun+0x140)
| p struct save_state 0.0xd4dd8e0
+------------- TRAP ----------------------------
4) pm_setrun+0x140
5) chanq_timer_expire+0x17c
6) invoke_callouts_for_self+0xc0
7) sw_service+0xb0
8) mp_ext_interrupt+0x150
9) ihandler+0x904
+------------- TRAP ----------------------------
| Trap type 4 in USER mode at 0xc45f000.0x35e58
| p struct save_state 0.0xd4dd000
+------------- TRAP ----------------------------
PHKL_24943:
( SR:8606182941 CR:JAGad5215 )
Application thread hangs when restarted after using
_lwp_setstate to change its PC (program counter).
PHKL_24734:
( SR:8606196287 CR:JAGad65490 )
Select(2) when called with zero file descriptors and a zero
timeout value, does not return immediately as it is
supposed to, according to the man page.
PHKL_24753:
( SR: 8606223152 CR: JAGad92255 )
Application threads using select() can miss calls to
unselect(), essentially missing an event that occurs
over a short duration.
As a result of missing the event, the application and
thread will become either hung or unkillable.
PHKL_24752:
( SR:8606196546 CR:JAGad65749 )
When threads are waiting on libpthread spinlocks, an
application may not be able to take advantage of idle CPU
cycles.
PHKL_23955:
( SR:8606185652 CR:JAGad54854 )
When a multi-threaded program contends on a mutex or a set
of mutexes, the time spent in system calls (i.e.
sched_yield, ksleep, and kwakeup), with non-realtime
workload, causes severe performance degradation.
The symptoms of the problem are the extremely high ratio of
system to user CPU time and a high call frequency to
sched_yield(), ksleep() and kwakeup().
PHKL_23002:
( SR:8606164923 CR:JAGad34221 )
The kernel may crash or hang in ksleep(), kwakeup(),
or chanq_*() routines after the value of the tunable
"chanq_hash_locks" is changed to something greater 256.
Alternatively, these functions may corrupt other kernel
global data, causing other modules to crash, hang, or
misbehave. In the case that a panic occurs, the stack
trace might look similar to to the one below:
stack trace for event 0
crash event was a panic
panic+0x14
report_trap_or_int_and_panic+0x80
trap+0xdb8
nokgdb+0x8
chanq_lookup+0x4c
ksleep_one+0xc4
ksleep+0xd4
syscall+0x200
$syscallrtn+0x0
PHKL_22940:
( SR: 8606167399 CR: JAGad36685 )
Occasionally a thread would miss a timeout interrupt
and sleep forever or until it was sent a signal. The
sleeping thread could cause an application hang.
PHKL_20202:
( SR: 8606128857 CR: JAGab14278 )
System panics while using nfs/tcp, ksleep_one() appears
in the panic stack trace.
PHKL_14750:
The previous patch has been recut to include compile-based
performance tuning. There is no functional change in this
patch.
PHKL_14493:
pthread_cond_timedwait(3T) intermittently returns EINVAL
though the arguments are all valid.
PHKL_24733:
( SR: 8606198999 CR: JAGad68186 )
The system hangs due to the searching of long thread lists
to deliver a signal when that signal is masked by all
threads in the process.
PHKL_23842:
( SR: 8606185342 CR: JAGad54537 )
Runnable threads may trigger false ServiceGuard failovers
after long dispatch latency in the kernel.
PHKL_23407:
(SR: 8606103740 CR: JAGab70789)
(SR: 8606159451 CR: JAGad28779)
A multi-threaded process being executed over NFS can become
hung and unkillable while performing either a fork, core,
setrlimit, SIGSTOP, or debugger operations.
PHKL_23001:
( SR: 8606161075 CR: JAGad30393 )
A multithreaded process may not always perform the desired
signal handler action if the system V signal(2) interface
is used or if the SA_RESETHAND flag is set with the other
signalling interfaces. This could occur when the process
must handle more than one instance of the same signal in
parallel. Similar problems with signal handling could
occur if the user calls sigaction() while the signal is
being processed. The most likely results of handling the
action incorrectly would be for the process to be
terminated or for a user specified action to be performed
more than once before the signal action is reset to
SIG_DFL.
PHKL_22568:
( SR: 8606163813 CR: JAGad33117 )
A multithreaded private third quadrant process will core
dump.
PHKL_22145:
( SR: 8606141357 CR: JAGad10718 )
Multi-threaded processes may not respond to SIGKILL,
SIGSTOP, or SIGCONT making the process "unkillable".
PHKL_21830:
( SR: 8606127468 CR: JAGac77753 )
User can incorrectly create a thread and bind it to a
deallocated processor.
Note that this defect can only be seen when processors
have been deallocated explicitly through administrator
intervention.
PHKL_21348:
( SR: 8606124297 CR: JAGac39680 )
When an application specifies signal(SIGCHLD,SIG_IGN)
and forks a child, it still gets interrupted when
the child exits. This premature interruption also occurs
in SIGCONT/SIG_IGN.
( SR: 8606132611 CR: JAGad01760)
The Praesidium IDS/9000 product requires this patch in order
to run. This change has no impact on systems without the
Praesidium IDS/9000 product installed and enabled.
PHKL_20942:
( SR: 8606112164 DTS: JAGab84450 )
Enhancement: Performance changes for corner case in RTSCHED
scheduling. This patch has no impact on most systems.
PHKL_20625:
( SR: 8606110344 CR: JAGab83048 )
UP system panics with Data Page Fault:
panic+0x14
report_trap_or_int_and_panic+0x4c
trap+0xea8
$RDB_trap_patch+0x38
ksw_remove_from_proc+0x5c
sigsuspend+0x1c0
syscall+0x1c8
$syscallrtn+0x0
PHKL_19930:
( SR: 8606103530 DTS: JAGab70391 )
Delivery of signals to processes with many (1000's) threads
is very slow and significantly reduces system throughput.
PHKL_19531:
( SR: 1653296996 DTS: JAGaa94126 )
Immediate return from delays with time interval requests in
excess of 2^31-1 seconds. The limit is now 2^32-1 for
32-bit systems, and 2^64-1 64-bit systems.
PHKL_24502:
( SR: 8606170321 CR: JAGad39585 )
Performance and response time degradation may be seen when
the fair share scheduler is run on a lightly loaded system
with 24 or more processors.
PHKL_23617:
( SR: 8606186407 CR: JAGad55611 )
Excessive entries in the system log for events signalling
override of mandatory binding can cause the system log to
fill up. Syslog availability is critical to some customers.
Following are the two samples of the unwanted log messages:
Jan 11 15:16:00 ssfih06 vmunix: mpc_bindlwp: Overriding
conflicting mandatory binding!
Jan 11 15:16:00 ssfih06 vmunix: mpc_bindlwp: Migrating
process 2450 from processor 1 to processor 0 !
( SR: 8606185342 CR: JAGad54537 )
Runnable threads may trigger false ServiceGuard failovers
after long dispatch latency in the kernel.
PHKL_23408:
A multi-threaded process being executed over NFS can
become hung and unkillable while performing one of a
fork, core, setrlimit, SIGSTOP, or debugger operations.
PHKL_23180:
( SR:8606173973 CR:JAGad43226 )
When mpctl() is called with MPC_GETNEXTSPU and arg1 has a
negative value, the system will panic with a Data Page
Fault. The strack trace is as follows:
panic+0x14
report_trap_or_int_and_panic+0x80
trap+0xdb8
thandler+0xd20
mpctl+0x158
syscall+0x480
syscallinit+0x54c
PHKL_21832:
(SR: 8606127468 CR: JAGac77753)
System call mpctl(2) using arguments MPC_GETNUMSPUS,
MPC_GETFIRSTSPU, and MPC_GETNEXTSPU, can incorrectly return
information on processors that have already been
deallocated.
Performance degrades when processors are deallocated.
The loss in performance is greater than what the inactive
processors account for.
Threads may be incorrectly scheduled on deallocated
processors.
Note that these defects can only be seen when processors
have been deallocated explicitly through administrator
intervention.
PHKL_21111:
(SR: 8606106739 CR: JAGab76092)
The capping feature of the fair share scheduler causes
severe performance problems for underloaded multi-processor
systems.
(SR: 8606104136 CR: JAGab71488)
PHKL_20883 can potentially cause panic with floating-point
underflow exception.
PHKL_20883:
(SR: 8606104136 CR: JAGab71488)
System appears to hang when a realtime thread, such as
midaemon, manages to starve all other threads on the same
processor. The thread balancing across multiple processors
does not happen.
PHKL_20941:
( SR: 8606112164 DTS: JAGab84450 )
PHKL_20941 enhances the execution of rtsched threads by
optimizing the scheduler to take into consideration the
current SPU that the thread is running on.
PHKL_20659:
(SR: 8606114252 CR: JAGac23971)
Panic in pm_setrun() due to sleeping thread not on sleepq.
Following is the stack trace footprint that exhibits the
problem:
0) panic+0x14
1) report_trap_or_int_and_panic+0x80
2) interrupt+0x1d4
3) $ihndlr_rtn+0x0
4) pm_setrun+0x140
5) pm_signalx+0x288
6) pm_psignalx+0x54
7) ktimer_expire+0x204
8) invoke_callouts_for_self+0xc0
9) sw_service+0xb0
10) mp_ext_interrupt+0x144
11) ivti_patch_to_nop3+0x0
12) idle+0x43c
13) swidle_exit+0x0
PHKL_20399:
(SR: 8606105735 CR: JAGab73995)
On multi processor systems, after a reboot, the system may
hang due to a defect in idle() loop.
PHKL_19873:
With FSS enabled on an MP system and where process groups
have fewer processes than CPUs, process performance is
less than expected for the CPU resource 'share' requested.
This results in a 5-20% performance hit on MP systems.
PHKL_22589:
( SR: 8606163603 CR: JAGad32907 )
After PHKL_18543 is installed, select() will incorrectly
return 0 when it is interrupted after being called with no
file descriptors and a timeout. According to the X/Open
standard, select() should return -1 for this case.
PHKL_22517:
( SR: 8606163287 CR:JAGad32591 )
Data Page Fault in getmount_entry() system call. The panic
stack might look like,
panic+0x14
report_trap_or_int_and_panic+0x80
trap+0xdb8
nokgdb+0x8
vx_active_common_flush+0xb8
vx_getmount+0x4c
getmount_entry+0x140
syscall+0x480
$syscallrtn+0x0
PHKL_22142:
( SR: 8606126449 CR:JAGac57014 )
When using select() with a large number of BSD socket
file descriptors, performance degradation is observed.
PHKL_21608:
( SR: 8606133836 CR:JAGad02977 )
Users see a PANIC with 'lo_realvfs' message.
The following stack trace is seen:
panic+0x14
lo_realvfs+0x9c
freelonode+0xdc
lo_inactive+0x124
locallookuppn+0x4fc
lookuppn+0xf8
lookupname+0x40
vn_open+0x68
copen+0xd0
open+0x3c
syscall+0x480
$syscallrtn+0x0
PHKL_21361:
( SR: 8606132624 CR: JAGad01773 )
The Praesidium IDS/9000 product requires this patch in order
to run. This patch has no impact on systems without the
Praesidium IDS/9000 product installed and enabled.
PHKL_20315:
( SR: 8606109444 DTS: JAGab82146 )
A system may panic in lo_realvfs() when using LOFS
file systems.
( SR: 4701423798 DTS: JAGab13874 )
The system may hang using LOFS if the directory being
mounted and the mount point are the same.
To reproduce the problem:
# mount -F lofs /mnt /mnt
# ls /mnt
This process will loop in the kernel indefinitely.
( SR: 1653263962 DTS: JAGaa12500 )
There are two types of failures that may be observed with
this problem.
1) A stale file handle is returned when mounting an
LOFS file system over NFS
2) Loopback mounts fail for direct map pathname from
AUTOFS (automount); this is an enhancement in LOFS
to support AUTOFS.
( SR: 4701393884 CR: JAGaa08709 )
A directory mounted via the loop-back file system
(LOFS) can be removed, thus making the mount inaccessible.
PHKL_15689:
vfs.o:
1. Cannot create AutoFS mount points.
autosysgen.o:
1. 32-bit AutoFS commands fail on 64-bit
OS.
PHKL_20349:
( SR: 8606110852 CR: JAGab83602 )
Enhancement to provide support for the pread(2) and
pwrite(2) system calls.
PHKL_14119:
( SR: 4701375543 DTS: DSDe440886 )
The original instance of this patch, PHKL_13290, was not
marked as a critical patch. It should have been.
PHKL_13290:
( SR: 4701375543 DTS: DSDe440886 )
System calls with signed integer arguments called from
32-bit binary programs may behave incorrectly when passed
negative values, while running on 64 bit systems. This
defect only impacts 64 bit systems.
Defect Description:
PHKL_25999:
( SR:8606230577 CR:JAGad99627 )
Debug threads were incorrectly left on the signalable
threads list for a process. This defect was found at HP
during product testing of the shared mutex performance
improvement. To our knowledge, no customer system has
experienced this defect.
Resolution:
Ensure the debug thread is not on the signalable threads
list at the time of its creation.
( SR:8606186056 CR:JAGad55261 )
In the PTHREAD_PROCESS_SHARED mutex case, the unlock
operation always makes a system call to synchronize with
threads in other processes which may be waiting for the
mutex. This makes the code path significantly longer.
Resolution:
To increase shared mutex performance in the non-contended
(i.e., no waiters) case, this change adds a new light weight
system call to be used in place of the regular system call
in the unlock operation. This is entirely transparent to
the applications. It greatly reduces the transition time
between kernel and user space. If waiters are detected,
the light weight call will transfer into the regular system
call path for proper handling. Thus, this performance
enhancement is effective only for shared mutexes which do
not experience heavy contention. (Patch PHKL_25998, also
required for this enhancement, adapts the existing system
call which handles waiters of shared mutexes to coordinate
with the light weight call. Patch PHCO_26000, also
required for this enhancement, adapts the libpthread
library to use the new light weight system call.)
( SR:8606230581 CR:JAGad99631 )
A signal used by the pthreads library to terminate system
calls can be lost if it is received within a small window of
instructions in the libpthread or libc libraries. If the
thread happens to be handling a trap (e.g., page fault)
within that window, the signal is lost. Thus, it is not
consumed in the subsequent system call for which it was
intended. This can result in the thread failing to be
properly cancelled.
Resolution:
Detect that the thread is handling a trap, and if so,
leave the signal pending rather than consume it. It will
then be available to be consumed in, and thus terminate,
the subsequent system call.
( SR:8606221319 CR:JAGad90453 )
PRM is being used to create and manage PRM groups for which
we want to set a given CPU entitlement with CPU capping
enabled. If all CPUs are enabled, the PRM CPU entitlements
are being enforced (capped) for each of the PRM groups.
When iCOD is used to disable CPUs, PRM reports the correct
number of CPUs (available), but the PRM CPU entitlements
are not being enforced (capped) correctly and PRM groups
are allowed to exceed their CPU entitlement. The problem is
that the iCOD dynamic change in the number of active CPUs on
the system is not being reported to the PRM scheduler.
Resolution:
In the clock tick handler, check whether the CPU is enabled.
If not enabled, do not update PRM group data.
( SR:8606228779 CR:JAGad97833 )
Currently, only 60 characters of the process command line is
stored in the kernel. Some environments require more
characters be stored.
Resolution:
This change handles deallocation of the dynamically
allocated kernel memory used to store up to 1020 characters
of the command line. (Patch PHKL_26008, also needed for
this enhancement, performs allocations and value assignments
of the command line data.)
PHKL_23226:
( SR: 8606175710 CR: JAGad44950 )
The lightweight version of the umask(2) system call was
incorrectly manipulating 12 of the file permission bits
instead of the correct number of 9.
Resolution:
Modify the lightweight version of the umask(2) system call
to manipulate only 9 file permission bits instead of 12.
PHKL_22796:
(SR:8606170084 CR:JAGad39348)
Add a check just after entering the system call to check
if we are allowed to come into the specified address
space.
Resolution:
Add an additional check.
PHKL_20245:
( SR: 8606102049 CR: JAGab67439 )
Desc: msem_lock() call occasionally fails w/EINVAL
In one customer instance, the protections in the TLB entry
lose 'write' access and so a msem_lock() call to _mcas()
will occasionally fail. This results in errno 14 EINVAL
rather than a re-try. However, an immediate second call
to msem_lock() does not fail.
Resolution:
Two lines of code, added to the lw_mcas_pageok() function,
pre-read the page. A pre-read page fault will trap and
cause a re-try instead of returning a fault.
PHKL_20236:
( SR: 4701409169 DTS: JAGaa12229 )
__lw_get_thread_times sometimes resets the W-bit when
returning to user-space. This causes incorrect calculation
of system time. This does not happen frequently, but if
__lw_get_thread_times() is called repeatedly, sometimes it
will return an incorrect system time.
Resolution:
The __lw_get_thread_times() routine was corrected to not
reset the wide-mode bit in the PSW when returning to the
user.
PHKL_25475:
( SR:8606221043 CR:JAGad90179 )
The kernel build fails with PHKL_23002 and superseding
patches because the header file
/usr/conf/space.h.d/core-hpux.h delivered in the patches
attempts to include spinlock.h from the location where it
is installed for the optional product ProgSupport.C-INC
fileset. Thus, in a minimal operating environment that
does not have this fileset installed,
/usr/include/sys/spinlock.h may not exist on the system
and the above error occurs.
Resolution:
/usr/conf/space.h.d/core-hpux.h now includes spinlock.h
from the location where it is installed for the required
kernel fileset (/usr/conf/h/spinlock.h).
( SR:8606220050 CR:JAGad89191 )
There are several outstanding issues with the priority
inversion implementation as introduced in PHKL_23955.
With priority inversion turned off, these symptoms are
not observed.
Resolution:
This patch disables priority inversion. A future
patch will re-enable it as a tunable once the
outstanding implementation issues have been addressed.
( SR:8606199334 CR:JAGad68521 )
To prevent a thread from going to sleep, PHKL_22940 set the
kt_wchan to NULL. This caused the thread to wake up, but
keft it on the sleep queue. Later execution of this thread
could corrupt all sleep queues on the system.
Resolution:
Rather than setting kt_wchan to NULL, call unsleep, which
will set kt_wchan to NULL and remove the thread from the
sleep queue.
PHKL_24943:
( SR:8606182941 CR:JAGad5215 )
W-bit of IPSW (interrupt processor status word) and lower
bits of GR31 (general register 31) are incorrectly set in
_lwp_setstate and _lwp_getstate.
Resolution:
In _lwp_getstate, save the IPSW from the target thread so
that the IPSW can be restored in _lwp_setstate.
In _lwp_setstate, put the IPSW bits in the target space id
if the user specifies LWP_SET_CONTROL. Otherwise clean up
the IPSW inherited from the thread.
PHKL_24734:
( SR:8606196287 CR:JAGad65490 )
When calling select(2) with zero file descriptors, select(2)
behaves as a sleep routine, returning back to the user after
the specified timeout. Currently, when a timeout of zero is
specified, select(2) sleeps for one clock tick before
realizing the timout has been exceeded.
Resolution:
Select(2) now detects when the user application requests a
zero timeout value and acts appropriately.
PHKL_24753:
( SR: 8606223152 CR: JAGad92255 )
When the thread lock is acquired for a sleeping thread, and
the sleep lock has not yet been obtained, the thread lock
must be released before obtaining the sleep lock, and then
reacquired. While the thread lock is released, a race
condition exists where the thread could change state.
The thread hang occurs due to a missed unsleep() (or
permanently missed wakeup).
Resolution:
Acquire the sleep lock prior to acquiring the thread lock
and calling unsleep().
PHKL_24752:
( SR:8606196546 CR:JAGad65749 )
The kernel routine managing a thread that is releasing a
spinlock does not check to see if other threads are waiting
for it. These threads could minimize their wait time if
woken up earlier. Currently they may wait from 10 to 20ms
before one is assigned the spinlock. For the case where
many threads are serialized on the spinlock, the cumulative
delay per thread may yield a noticeable performance
degradation.
Resolution:
In the above kernel routine, after the spinlock becomes
available, it now checks for and wakes up the threads
waiting for the spinlock.
PHKL_23955:
( SR:8606185652 CR:JAGad54854 )
This issue affects applications with many threads where
there is contention on a mutex or a set of mutexes. A
non-realtime thread in user space is vulnerable to
preemption by the kernel if a higher priority thread becomes
runnable in the kernel. This is very likely since threads
sleeping on resources in the kernel wake up at higher
priority. This causes a user thread holding a mutex to be
blocked waiting to run while other threads are either
spinning or blocked on the same mutex. The overall
throughput of a multi-threaded application with
synchronization is reduced noticeably.
Resolution:
When a timeshare thread returns from ksleep() having
acquired the resource (e.g. mutex), the operating system
gives the thread a temporary priority boost. The new
priority is high enough that its probability of getting
preempted by kernel space threads becoming runnable is
reduced. The thread will now have enough time and priority
to complete its job in user space such that it can release
the mutex. Since the timeshare scheduler recomputes the
thread priority at regular intervals, the original priority
for the thread will be restored in the near future.
PHKL_23002:
( SR:8606164923 CR:JAGad34221 )
The tunable chanq_hash_locks was never implemented properly.
Changing the tunable changed the size of the spinlock pool
for channel queues, but not the size of the two hashtables
that were assosciated with the spinlock pool. The
hashtables actual upper bound was left at 256, but
functions CHANQ_KERNEL_HASH_MACRO() and
CHANQ_USER_HASH_MACRO() would be using the size of the
spinlock pool as the upper bound to the hash table size. If
the tunable had been set to larger than 256, this would
eventually lead to creating a hashtable entry outside of
the memory allocated to the hashtables when user programs
attempted to create threads.
Resolution:
The tunable chanq_hash_locks was implemented so that it was
used to set the size of the chanq_h_sl_pool and also the
two associated hashtables. Additionally, a lower bound of
64 and an upper bound of 4096 were set for this tunable.
PHKL_22940:
( SR: 8606167399 CR: JAGad36685 )
A timing window existed in the sleep routines such that
if the timeout interrupt occurred before the thread had
gone to sleep, the thread would miss the timeout and
sleep forever, or until it was sent a signal.
Resolution:
Modified the timeout interrupt routine to correctly
handle the case where the thread is not yet asleep when
the timeout interrupt occurs.
PHKL_20202:
( SR: 8606128857 CR: JAGab14278 )
Calling the kwakup_one() function from ICS panics the
system. The immediate problem is that chanq_setkey()
dereferences the uarea to get at the vas via the proc
structure.
Resolution:
By rearranging the code so the vas pointer is not
initialized until after the KERNEL_ADDRESS-specific
code is executed, we'll avoid dereferencing the uarea
on the ICS.
PHKL_14750:
None
PHKL_14493:
Under normal circumstances, if the third argument
"struct timespec *abstime" to pthread_cond_timedwait()
contains the time it has already passed, it will return
error ETIMEDOUT. However, pthread_cond_timedwait(3T)
intermittently returns EINVAL instead. This happens in the
following scenario:
- pthread_cond_timedwait() gets called with a future time.
- pthread_cond_timedwait() calls ksleep()
- ksleep() calls ksleep_one()
- ksleep() calls chang_timeout()
If by the time we call chang_timeout(), the time value is
already in the past, chang_timeout() returns EINVAL. This
return value is propagated and eventually returned by
pthread_cond_timedwait().
The fix was to make sure that this scenario now returns
ETIMEDOUT instead.
PHKL_24733:
( SR: 8606198999 CR: JAGad68186 )
In order to find a thread that can handle a signal directed
at the process, all non-running threads are examined to see
if they will handle that signal. However, if the signal is
blocked by all the threads of a process, the signal cannot
be delivered to a thread and must be left pending at the
process level. This then causes the system to continually
try to deliver the signal whenever the system is switching
from kernel mode to user mode. With a large number of
threads, these searches can consume all the CPU resources.
Resolution:
The number of times the entire list of threads is searched
is reduced greatly by keeping track that a previous search
has found that all the non-running threads have that signal
masked and then not searching that list of threads if the
search has already been done.
PHKL_23842:
( SR: 8606185342 CR: JAGad54537 )
The application and database level heartbeat technology
requires reasonable responsiveness in the 50 to 100 ms range
to assure application availability. Long running paths in
the kernel can lead to threads running for a long time in
an uninterruptible state.
This patch enables the preemption mechanism by turning on
a variable which is checked at every possible preemption
point. If this variable is enabled, and if we have spent
too much time in the kernel, then we will preempt the
currently running kernel thread in favor of the higher
priority thread. If the variable is not turned on (because
this patch, or a successor, is not installed), preemption
will not occur regardless of time spent in the kernel.
Resolution:
This patch, along with 5 other patches, helps alleviate this
problem by improving the dispatch latency for higher
priority runnable threads. This is done by improving the
preemption functionality along the long running kernel code
paths.
This set of patches will not necessarily benefit all
application mixes since some application mixes may not
execute the modified code paths.
The other 5 patches which work in conjunction with this
patch are PHKL_23617, PHKL_20943, PHKL_20944, PHKL_20945,
and PHKL_21024. Installation of each patch alone will have
no effect on the system.
A minimal set of patches to achieve this thread scheduling
fix must include PHKL_23617, PHKL_23842 and PHKL_20944.
However, all patches should be installed to achieve the full
effect.
PHKL_23407:
(SR: 8606103740 CR: JAGab70789)
(SR: 8606159451 CR: JAGad28779)
A thread acquires a lock and then sleeps interruptibly. The
interruptible sleep permits the thread to be stopped. Any
other thread attempting to acquire this lock will sleep
uninterruptably until the lock is available. This
uninterruptable thread is also unkillable. This introduces
a deadlock potential in multi-threaded processes: when a
thread holding the lock, a thread desiring the lock, and a
third thread doing one of fork, setrlimit, core, SIGSTOP, or
debugger optionations, all occur at the same time in the
same process, the deadlock is reached. The only way to
resolve the deadlock is to reboot the system.
This patch is part of a set of four patches (PHKL_23406,
PHKL_23407,PHKL_23408,PHKL_23409) that enable P_NOSTOP, a
new feature that prevents a process from being unkillable.
Each patch is independantly installable. Without all four
installed, the P_NOSTOP feature will be unavailable.
In order to prevent the process executed over NFS from
becoming unkillable, NFS must use the P_NOSTOP feature. An
NFS patch using P_NOSTOP, PHNE_23249, will be released in
Spring of 2001.
Resolution:
If a thread acquires a lock and then sleeps interruptably,
it is not permitted to be stopped if P_NOSTOP is set. This
prevents this thread from becoming unkillable and prevents
the deadlock.
PHKL_23001:
( SR: 8606161075 CR: JAGad30393 )
The possibility of the wrong signal action being executed
results from a race condition that occurs between issig()
and psig(). This race condition is caused by checking the
signal's action in issig(), using that value to determine
if the signal needs to be processed by psig(), and then
releasing the thread and scheduler locks before issig()
returns. Upon returning from issig(), psig() is called and
checks the signal's action again, while holding no locks.
This leaves a window of time that allows for the signal's
action to be changed between when issig() determines the
signal should be handled by psig() and when psig() checks
what action should be performed. This results in two
possible error cases: that the action will be SIG_DFL, but
psig() won't know how to perform the default action for
that signal, or that a user specified action will be used
when the action should have been reset to SIG_DFL.
Resolution:
When the system V signal(2) interface or the standard
interface with the SA_RESETHAND flag set are used, the
signal action was checked a second time in psig() after the
scheduler lock is obtained. After this check is made, if
the action is SIG_DFL, then we know the race condition
has occured and psig() will then perform the default action
for that signal. psig() was also modified so that it would
be able to handle SIGIO in addition to the six signals that
have a default action of ignore.
PHKL_22568:
( SR: 8606163813 CR: JAGad33117 )
If a private third quadrant process creates another thread,
the kernel does not initialize sr6 (the space register that
controls the third quadrant address space) to the proper
value for that thread. Any access by that thread to an
address in the third quadrant will lead to a segmentation
violation.
Resolution:
The kernel procedure which initializes registers for new
threads has been modified to set sr6 properly (i.e. the
same value that is in sr5, which is the users private
address space).
PHKL_22145:
( SR: 8606141357 CR: JAGad10781 )
The process does not respond to the signals SIGKILL,
SIGSTOP, and SIGCONT as these will be directed
to the first thread of the process without checking
to see if that thread is a zombie thread. This selection
is made in the find_first_eligible_thread function. If
it's a zombie it does nothing to handle the signal.
Note that this does not affect other signals as the
threads they are passed to are selected in a different
manner.
Resolution:
Change find_first_eligible_thread so that it passes
the signals noted above to the first non-zombie
thread rather than automatically choosing the first
thread.
PHKL_21830:
( SR: 8606127468 CR: JAGac77753 )
Procedure thread_create() does not check if the processor is
currently deallocated.
Resolution:
Change thread_create() to fail and set errno to EINVAL if a
thread is set to bound to a deallocated processor.
PHKL_21348:
( SR: 8606124297 CR: JAGac39680 )
Parent issues a signal(SIGCHLD,SIG_IGN) to prevent
exiting children from creating zombie processes.
Before 11.00, when the child exits, the parent is
woken up by the signal. If SIGCHLD/SIG_IGN is set,
it reaps the zombies, discards the child, ignores
the signal and goes back to sleep. In 11.00, thread
house cleaning is added in the sigsuspend() and
sigpause() paths such that the parent is not put
back to sleep after waking up, resulting in the
premature interruption of the parent.
Resolution:
In 11.00, since the reaping of zombies is done by the
child during exit, there is no need for the parent to be
woken up when a child exits. Therefore SIGCHLD/SIG_IGN
can be handled as SIGCHLD/SIG_DFL by not posting the
signal when a child exits.
Similar fix applies to SIGCONT/SIG_IGN.
( SR: 8606132611 CR: JAGad01760 )
This patch is one of 16 patches (PHKL_21348-PHKL_21363)
required by the Praesidium IDS/9000 product. These patches
enable the collection and tracking of information from
various system calls. Unless all of the enabling patches
(or their successors) and the product are installed, and the
product is enabled, this change has no impact on the system.
Resolution:
This patch provides the interface required by IDS/9000 for
thread and process creation and teardown.
PHKL_20942:
( SR: 8606112164 DTS: JAGab84450 )
This is an enhancement for a corner case in RTSCHED
scheduling.
Resolution:
Code added to fine tune RTSCHED thread scheduling code path.
PHKL_20625:
( SR: 8606110344 CR: JAGab83048 )
Before calling ksw_remove_from_proc(), only MP locking
of the sched lock takes place and no UP locking is done.
During the execution of ksw_remove_from_proc(), if the
system services an I/O or timer interrupt on the interrupt
control stack without the lock protection, the ksigwait
structure is removed before the completion of
ksw_remove_from_proc(). Data page fault happens when
this structure is accessed.
Resolution:
Use spinlock() instead of MP_SPINLOCK() to protect the
sched lock for both UP and MP.
PHKL_19930:
( SR: 8606103530 DTS: JAGab70391 )
Signal delivery searched a single per-process linked list
for a candidate thread to deliver the signal to. If the
process is using AIO, it may have many threads that are
not candidates. These extra threads can significantly
slow the search.
Resolution:
Create a second per-process list populated only by threads
that can possibly handle signals.
PHKL_19531:
( SR: 1653296996 DTS: JAGaa94126 )
Specifying "sleep 99999999" will terminate immediately.
Any request in excess of 2^31-1 seconds will fail and
return immediately.
Resolution:
The sigtimedwait algorthim has been corrected to accomodate
delays of 2^32-1 for 32-bit systems, and 2^64-1 64-bit
systems by itteratively handling the requested time using
one or more pre-defined delays plus a residual.
PHKL_24502:
( SR: 8606170321 CR: JAGad39585 )
When running the fair share scheduler on a lightly loaded
system with 24 or more processors, too much time was spent
in the fair share scheduler's idle loop searching other
processors' run queues for fair share scheduled threads to
steal.
Resolution:
This patch streamlines the fair share scheduler's idle
loop, reducing the amount of time we spend searching other
processors' run queues for fair share scheduled threads to
steal. This allows better overall system performance and
response time.
PHKL_23617:
( SR: 8606186407 CR: JAGad55611 )
When a user space mandatory binding request is found to be
in conflict with the actual spu it is running on, a syslog
message on the application'system daemons issues a warning
that the mpc_bindlwp() routine overrides the conflict
mandatory binding request. The extraneous message fills up
the log file making syslog unusable for the third party
product.
Resolution:
Add conditional flag enable_mpc_bindlwp_printf to
mpc_bindlwp() to skip printing "Overriding conflicting
mandatory binding!" message for a user space mandatory
binding request that is running on a processor different
from the requested processor and is also not gang
scheduled.
( SR: 8606185342 CR: JAGad54537 )
The application and database level heartbeat technology
requires reasonable responsiveness in the 50 to 100 ms range
to assure application availability. Long running paths in
the kernel can lead to threads running for a long time in
an uninterruptible state.
Resolution:
This patch, along with 5 other patches, helps alleviate this
problem by improving the dispatch latency for higher
priority runnable threads. This is done by improving the
preemption functionality along the long running kernel code
paths.
This set of patches will not necessarily benefit all
application mixes since some applications mixes may not
execute the modified code paths.
The other 5 patches which work in conjunction with this
patch are PHKL_23842, PHKL_20943, PHKL_20944, PHKL_20945,
and PHKL_21024. Installation of each patch alone will have
no effect on the system.
A minimal set of patches to achieve this thread scheduling
fix must include PHKL_23617, PHKL_23842 and PHKL_20944.
However, all patches should be installed to achieve the full
effect.
PHKL_23408:
(SR: 8606103740 CR: JAGab70789)
(SR: 8606159451 CR: JAGad28779)
A thread acquires a lock and then sleeps interruptibly.
The interruptible sleep permits the thread to be stopped.
Any other thread attempting to acquire this lock will
sleep uninterruptably until the lock is available. This
uninterruptable thread is also unkillable. This
introduces a deadlock potential in multi-threaded
processes: when a thread holding the lock, a thread
desiring the lock, and a third thread doing one of a
fork, setrlimit, core, SIGSTOP, or debugger operations,
all occur at the same time in the same process, the
deadlock is reached. The only way to resolve the deadlock
is to reboot the system.
This patch is part of a set of four patches (PHKL_23406,
PHKL_23407, PHKL_23408, and PHKL_23409) that enable
P_NOSTOP, a new feature that prevents a process from
becoming unkillable. Each patch is independently
installable. Without all four installed, P_NOSTOP will
be unavailable.
In order to prevent the process executed over NFS from
becoming unkillable, NFS must use the P_NOSTOP feature.
An NFS patch using P_NOSTOP, PHNE_23249, will be released
in Spring of 2001.
Resolution:
If a thread acquires a lock and then sleeps interruptably,
it is not permitted to be stopped if P_NOSTOP is set. This
prevents the thread from becoming unkillable and prevents
the deadlock.
PHKL_23180:
( SR:8606173973 CR:JAGad43226 )
The negative SPU value represented by arg1 is not valid, but
there aren't any checks for this before that value is used.
The usage of the invalid SPU results in the Data Page Fault.
Resolution:
A check was added to cause mpctl() to return with an error
if it is called with MPC_GETNEXTSPU and a negative value for
arg1.
PHKL_21832:
(SR: 8606127468 CR: JAGac77753)
Threads can be seen running on deallocated processors.
Performance does not scale well when processors deallocated.
mpctl() returns deallocated processors in MPC_GETFIRSTSPU
and MPC_GETNEXTSPU and count deallocated processors in
MPC_GETNUMSPUS.
Resolution:
Code was changed to check for spu_status before placing a
thread on its run queue and also to migrate threads to the
monarch when a processor is deallocated.
Code was changed in idle loop so that it does not hold
sched_lock at every iteration. Code was changed in mpctl()
so that it is aware of deallocated processors.
PHKL_21111:
(SR: 8606106739 CR: JAGab76092)
When FSS capping feature is enabled and when a minority
group is the only job running on the system on a mostly
idle system, the minority group doesn't achieve its
entitlement.
Resolution:
Modify existing FSS algorithm to allow admin defined
groups to steal a 'horse' from SYSTEM group when a group
doesn't achieve its entitlement.
Advance the carousel in idle loop when there is
no SYSTEM processes, which allows non-SYSTEM groups to run.
(SR: 8606104136 CR: JAGab71488)
Patch PHKL_20883 can cause floating-point underflow
exception which can panic the system.
Resolution:
This is corrected by setting 'D-bit' in floating-point
status register.
PHKL_20883:
(SR: 8606104136 CR: JAGab71488)
When a CPU is being monopolized by a realtime thread,
the high level load balancer (mp_spu_balance) failed to
migrate threads from this CPU to other less busy ones.
Resolution:
To alleviate the thread starvation caused by a realtime
thread, the balancer has been changed to run on the
Interrupt Control Stack. This enables the balancer code
to run on a regular preset interval despite the system
load. In addition, the load balancing algorithm has been
enhanced to proactively detect and prevent starvation
through its balancing score.
PHKL_20941:
( SR: 8606112164 DTS: JAGab84450 )
This patch optimizes RTSCHED thread scheduling along some
kernel code paths. The scheduler now optimizes which
processor to place the RTSCHED thread on.
1) only RTSCHED threads are affected. Threads scheduled via
the rtprio() command will not see any changes from this
patch.
2) SCHED_TIMSHARE threads may see some delay in response
time as RTSCHED threads will receive more system
resources.
3) This patch will not necessarily benefit all application
mixes which utilize RTSCHED capabilities since all
applications mixes may not execute the modified code
paths.
Resolution:
The scheduler will allow the rtsched thread to continue
execution on the current SPU if context switching is deemed
too expensive. Otherwise, it would choose the SPU most
appropriate, usually the one with the lightest load.
PHKL_20659:
(SR: 8606114252 CR: JAGac23971)
Kernel routine that inserts thread into the priority sleep
queue neglects to update the pointer to the tail of the
sleep queue triggering the effect of a ghosted thread. This
lead to system panics when trying to wake up the sleeping
threads.
The panic is caused by pm_setrun() not being able to find
the sleeping thread on slpque_1. The inquired thread is
still asleep with a valid kt_wchan and kt_stat state.
Resolution:
As inserted thread is appended to the end of the sleep
queue, the tail pointer of the queue is also updated.
PHKL_20399:
(SR: 8606105735 CR: JAGab73995)
When an MP system is rebooted and executed in the idle()
path, comparison check between nready_free and
nready_free_alpha was inadequate thus preventing the reboot
processor from handling threads locked to other specific
processor.
Resolution:
We now account properly for threads locked to other specific
processor in addition to active, not locked threads. The
reboot processor can now find and process active runnable
threads on other processor's run queue.
PHKL_19873:
Due to a misbehavior in 11.00 FSS, a resource 'share' is
incorrectly allocated on MP systems when the number of
processes in the group is less than the number of CPUs in
the system. The shares are allocated on a per CPU not per
system thus a group configured for 50% with just a single
process will get only 12.5% on a 4-way system.
Note that if the system has been tuned to compensate for the
problem fixed by this patch, it might be necessary for the
system to be re-tuned since system performance may change.
Resolution:
The fss_balance() algorithm which continually checks how
often the processes in each process group want to run now
ensures that even the minority group gets its fair share
of system resources even for 'minority' group processes.
PHKL_22589:
( SR: 8606163603 CR: JAGad32907 )
The performance update made to select() by PHKL_18543 did
not correctly handle the case of select() being interrupted
after being called with no file descriptors and a timeout.
Resolution:
The routine select_as_nanosleep() was updated to cause
select to return -1 with the error of type EINTR when the
above case occurred. This conforms to the X/Open standard.
PHKL_22517:
( SR: 8606163287 CR:JAGad32591 )
This is due to a race between two threads, one accessing the
details of a mounted file system and another unmounting the
same file system. getmount_entry() is holding an alpha
semaphore while retrieving the details of the mounted file
system. This semaphore may be released, if the filesystem
specific getmount_entry routine sleeps. Due to this another
thread doing an unmount of the file system would be able to
get the semaphore and thus could unmount the file system and
free the related data structures. Later the
getmount_entry() thread accesses the freed data structures
and panics.
Resolution:
Instead of relying only on the semaphore, get a hold on the
file system so that unmount will fail when getmount_entry()
is in progress.
PHKL_22142:
( SR: 8606126449 CR:JAGac57014 )
In order to improve the network performance, one more piece
of information is needed to pass from select(2) to its lower
functions in order to tell the lower functions if the
select(2) system call is going to sleep.
Resolution:
One more argument has been added to its lower function for
passing sleeping information, which enables performance
improvements in future Transport and STREAMS patches. This
patch alone will have no performance improvement if there
are no such Transport and STREAMS patches installed.
PHKL_21608:
( SR: 8606133836 CR:JAGad02977 )
This PANIC with 'lo_realvfs' message is because of a race
condition.
A race condition is created when one thread tries to create
an an lfs node and another thread tries to release the same
'lfs' node.
Thread 1 tries to free an 'lfs' node while holding a lock.
Thread 2 tries to make an 'lfs' node. But, due to the time
gap in holding and releasing the lock, a race condition is
created between Thread 1 and Thread 2.
This can lead to the PANIC with 'lo_realvfs' PANIC.
Resolution:
The fix is to increase and decrease the lfs_refct without
giving up the lock. Also the lfs_refct value checking has
been changed to refect the new change.
PHKL_21361:
( SR: 8606132624 CR: JAGad01773 )
This patch is one of 16 patches (PHKL_21348-PHKL_21363)
required by the Praesidium IDS/9000 product. These patches
enable the collection and tracking of information from
various system calls. Unless all of the enabling patches
(or their successors) and the product are installed, and the
product is enabled, this patch has no impact on the system.
Resolution:
This patch enables the gathering of information from the
filesystem system calls.
PHKL_20315:
( SR: 8606109444 DTS: JAGab82146 )
The problem is a race condition caused by not properly
protecting an entry in a lofs data structure. The lock that
is supposed to protect this structure was not held when an
update was made, and thus simultaneous changes resulted in
an inconsistency in the data structure, causing the panic.
Resolution:
The lock is now held when this entry is updated; this
is actually just obtaining the lock one line earlier in
the code.
( SR: 4701423798 DTS: JAGab13874 )
The problem is that the system will loop in the routine
trying to find the root of the file system.
Resolution:
The mount of a directory to itself is really an error. The
resolution is to change the code so the mount will fail with
EINVAL, thus avoiding the case where the hang will occur.
( SR: 1653263962 CR: JAGaa12500 )
The problem is that LOFS does not implement the VFS_VGET
operation, and thus does not properly call the underlying
file system functions. This functionality is needed for
AUTOFS to support overlaying of file systems.
Resolution:
The solution is to implement the VFS_VGET routine in LOFS,
so a new function lo_vget() has been added. This resolves
both symptoms of the problem.
( SR: 4701393884 CR: JAGaa08709 )
The problem is that LOFS does not properly add a reference
to the vnode of mount point. This allows 'rmdir' to remove
the directory because there appear to be no references to
it any more.
Resolution:
Add a new LOFS vnode which will add a reference to the mount
point vnode preventing the removal of the directory.
PHKL_15689:
vfs.o:
1. smount2() fails when vnode is of type
AutoFS.
autosysgen.o:
1. Data alignment is incorrect between the
32-bit automount command and the 64-bit
AutoFS system calls.
PHKL_20349:
( SR: 8606110852 CR: JAGab83602 )
Enhancement to add new pread(2), pwrite(2), pread64(2) and
pwrite64(2) system calls. These calls perform the same
action as read(2) and write(2) except that they read/write
from a given position in the file (specified in the fourth
argument) without changing the file pointer.
Resolution:
Added new system calls.
PHKL_14119:
( SR: 4701375543 DTS: DSDe440886 )
In order to set the critical tag on this file, a new patch
was required. This patch makes no other change, and is
technically equivalent to PHKL_13290.
PHKL_13290:
( SR: 4701375543 DTS: DSDe440886 )
Extract unsigned instruction used where signed extract
should have been used.
SR:
1653253237 1653263962 1653296996 4701375543 4701393884
4701409169 4701423798 5003424044 5003461889 8606102049
8606103530 8606103740 8606104136 8606105735 8606106739
8606109444 8606110344 8606110852 8606112164 8606114252
8606124297 8606126449 8606127468 8606128857 8606132611
8606132624 8606133836 8606141357 8606159451 8606161075
8606163287 8606163603 8606163813 8606164923 8606167399
8606170084 8606170321 8606173973 8606175710 8606182941
8606185342 8606185652 8606186056 8606186407 8606196287
8606196546 8606198999 8606199334 8606220050 8606221043
8606221319 8606228779 8606230577 8606230581
Patch Files:
OS-Core.CORE-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP:
/usr/conf/h/fss.h
/usr/conf/h/unistd.h
ProgSupport.C-INC,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP:
/usr/include/sys/fss.h
/usr/include/sys/ksleep.h
/usr/include/sys/unistd.h
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP:
/usr/conf/lib/libhp-ux.a(autosysgen.o)
/usr/conf/lib/libhp-ux.a(gateway.o)
/usr/conf/lib/libhp-ux.a(init_sent.o)
/usr/conf/lib/libhp-ux.a(kern_fork.o)
/usr/conf/lib/libhp-ux.a(kern_sig.o)
/usr/conf/lib/libhp-ux.a(lo_subr.o)
/usr/conf/lib/libhp-ux.a(lo_vfsops.o)
/usr/conf/lib/libhp-ux.a(lo_vnops.o)
/usr/conf/lib/libhp-ux.a(lw_scall.o)
/usr/conf/lib/libhp-ux.a(pm_clockint.o)
/usr/conf/lib/libhp-ux.a(pm_policy.o)
/usr/conf/lib/libhp-ux.a(pm_proc.o)
/usr/conf/lib/libhp-ux.a(pm_signal.o)
/usr/conf/lib/libhp-ux.a(pm_swtch.o)
/usr/conf/lib/libhp-ux.a(pm_threads.o)
/usr/conf/lib/libhp-ux.a(qmml.o)
/usr/conf/lib/libhp-ux.a(scall_stubs.o)
/usr/conf/lib/libhp-ux.a(subr_ksleep.o)
/usr/conf/lib/libhp-ux.a(subr_threads.o)
/usr/conf/lib/libhp-ux.a(sys_gen.o)
/usr/conf/lib/libhp-ux.a(vfs.o)
/usr/conf/lib/libhp-ux.a(vfs_vnode.o)
/usr/conf/lib/libprm.a(kern_fss.o)
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP:
/usr/conf/space.h.d/core-hpux.h
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP:
/usr/conf/lib/libhp-ux.a(autosysgen.o)
/usr/conf/lib/libhp-ux.a(gateway.o)
/usr/conf/lib/libhp-ux.a(init_sent.o)
/usr/conf/lib/libhp-ux.a(kern_fork.o)
/usr/conf/lib/libhp-ux.a(kern_sig.o)
/usr/conf/lib/libhp-ux.a(lo_subr.o)
/usr/conf/lib/libhp-ux.a(lo_vfsops.o)
/usr/conf/lib/libhp-ux.a(lo_vnops.o)
/usr/conf/lib/libhp-ux.a(lw_scall.o)
/usr/conf/lib/libhp-ux.a(pm_clockint.o)
/usr/conf/lib/libhp-ux.a(pm_policy.o)
/usr/conf/lib/libhp-ux.a(pm_proc.o)
/usr/conf/lib/libhp-ux.a(pm_signal.o)
/usr/conf/lib/libhp-ux.a(pm_swtch.o)
/usr/conf/lib/libhp-ux.a(pm_threads.o)
/usr/conf/lib/libhp-ux.a(qmml.o)
/usr/conf/lib/libhp-ux.a(scall_stubs.o)
/usr/conf/lib/libhp-ux.a(subr_ksleep.o)
/usr/conf/lib/libhp-ux.a(subr_threads.o)
/usr/conf/lib/libhp-ux.a(sys_gen.o)
/usr/conf/lib/libhp-ux.a(vfs.o)
/usr/conf/lib/libhp-ux.a(vfs_vnode.o)
/usr/conf/lib/libprm.a(kern_fss.o)
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP:
/usr/conf/space.h.d/core-hpux.h
what(1) Output:
OS-Core.CORE-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP:
/usr/conf/h/fss.h:
fss.h $Date: 1999/09/14 09:27:43 $Revision: r11ros/3
PATCH_11.00 (PHKL_19873) */
/usr/conf/h/unistd.h:
unistd.h $Date: 1999/12/06 12:15:20 $Revision: r11ro
s/6 PATCH_11.00 (PHKL_20349)
ProgSupport.C-INC,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP:
/usr/include/sys/fss.h:
fss.h $Date: 1999/09/14 09:27:43 $Revision: r11ros/3
PATCH_11.00 (PHKL_19873) */
/usr/include/sys/ksleep.h:
ksleep.h $Date: 2000/12/19 17:06:00 $Revision: r11ro
s/1 PATCH_11.00 (PHKL_23002)
$Revision: 1.4.105.5 $ */
/usr/include/sys/unistd.h:
unistd.h $Date: 1999/12/06 12:15:20 $Revision: r11ro
s/6 PATCH_11.00 (PHKL_20349)
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP:
/usr/conf/lib/libhp-ux.a(autosysgen.o):
None
/usr/conf/lib/libhp-ux.a(gateway.o):
gateway.s $Date: 2002/01/01 19:16:18 $Revision: r11r
os/3 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(init_sent.o):
init_sent.c $Date: 2002/01/01 19:18:12 $Revision: r1
1ros/2 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(kern_fork.o):
kern_fork.c $Date: 2001/02/15 14:53:16 $Revision: r1
1ros/13 PATCH_11.00 (PHKL_23407)
/usr/conf/lib/libhp-ux.a(kern_sig.o):
kern_sig.c $Date: 1999/12/07 14:02:53 $Revision: r11
ros/10 PATCH_11.00 (PHKL_20625)
/usr/conf/lib/libhp-ux.a(lo_subr.o):
lo_subr.c $Date: 2000/04/28 11:43:18 $Revision: r11r
os/2 PATCH_11.00 (PHKL_21608)
/usr/conf/lib/libhp-ux.a(lo_vfsops.o):
lo_vfsops.c $Date: 1999/12/02 07:19:10 $Revision: r1
1ros/1 PATCH_11.00 (PHKL_20315)
/usr/conf/lib/libhp-ux.a(lo_vnops.o):
lo_vnops.c $Date: 1999/12/02 07:19:10 $Revision: r11
ros/1 PATCH_11.00 (PHKL_20315)
/usr/conf/lib/libhp-ux.a(lw_scall.o):
lw_scall.s $Date: 2002/01/01 19:12:23 $Revision: r11
ros/13 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_clockint.o):
pm_clockint.c $Date: 2002/01/01 19:11:33 $Revision:
r11ros/9 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_policy.o):
pm_policy.c $Date: 2001/04/05 18:18:43 $Revision: r1
1ros/20 PATCH_11.00 (PHKL_23617)
/usr/conf/lib/libhp-ux.a(pm_proc.o):
pm_proc.c $Date: 2002/01/01 19:09:09 $Revision: r11r
os/16 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_signal.o):
pm_signal.c $Date: 2002/01/01 19:09:57 $Revision: r1
1ros/19 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_swtch.o):
pm_swtch.c $Date: 2001/08/14 15:43:42 $Revision: r11
ros/29 PATCH_11.00 (PHKL_24943)
/usr/conf/lib/libhp-ux.a(pm_threads.o):
pm_threads.c $Date: 2002/01/01 19:10:42 $Revision: r
11ros/21 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(qmml.o):
qmml.s $Date: 2000/11/21 12:30:35 $Revision: r11ros/
1 PATCH_11.00 (PHKL_22796)
/usr/conf/lib/libhp-ux.a(scall_stubs.o):
scall_stubs.s $Date: 2002/01/01 19:17:27 $Revision:
r11ros/4 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(subr_ksleep.o):
subr_ksleep.c $Date: 2001/10/16 07:31:33 $Revision:
r11ros/10 PATCH_11.00 (PHKL_25475)
/usr/conf/lib/libhp-ux.a(subr_threads.o):
subr_threads.c $Date: 2001/08/14 15:43:42 $Revision:
r11ros/17 PATCH_11.00 (PHKL_24943)
/usr/conf/lib/libhp-ux.a(sys_gen.o):
sys_gen.c $Date: 2001/08/14 15:43:42 $Revision: r11r
os/13 PATCH_11.00 (PHKL_24943)
/usr/conf/lib/libhp-ux.a(vfs.o):
vfs.c $Date: 2000/10/16 10:32:49 $Revision: r11ros/6
PATCH_11.00 (PHKL_22517)
/usr/conf/lib/libhp-ux.a(vfs_vnode.o):
vfs_vnode.c $Date: 2000/03/17 11:52:36 $Revision: r1
1ros/5 PATCH_11.00 (PHKL_21361)
/usr/conf/lib/libprm.a(kern_fss.o):
kern_fss.c $Date: 1999/09/14 09:27:43 $Revision: r11
ros/5 PATCH_11.00 (PHKL_19873)
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP:
/usr/conf/space.h.d/core-hpux.h:
core-hpux.h $Date: 2001/10/16 07:35:28 $Revision: r1
1ros/11 PATCH_11.00 (PHKL_25475)
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP:
/usr/conf/lib/libhp-ux.a(autosysgen.o):
None
/usr/conf/lib/libhp-ux.a(gateway.o):
gateway.s $Date: 2002/01/01 19:16:18 $Revision: r11r
os/3 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(init_sent.o):
init_sent.c $Date: 2002/01/01 19:18:12 $Revision: r1
1ros/2 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(kern_fork.o):
kern_fork.c $Date: 2001/02/15 14:53:16 $Revision: r1
1ros/13 PATCH_11.00 (PHKL_23407)
/usr/conf/lib/libhp-ux.a(kern_sig.o):
kern_sig.c $Date: 1999/12/07 14:02:53 $Revision: r11
ros/10 PATCH_11.00 (PHKL_20625)
/usr/conf/lib/libhp-ux.a(lo_subr.o):
lo_subr.c $Date: 2000/04/28 11:43:18 $Revision: r11r
os/2 PATCH_11.00 (PHKL_21608)
/usr/conf/lib/libhp-ux.a(lo_vfsops.o):
lo_vfsops.c $Date: 1999/12/02 07:19:10 $Revision: r1
1ros/1 PATCH_11.00 (PHKL_20315)
/usr/conf/lib/libhp-ux.a(lo_vnops.o):
lo_vnops.c $Date: 1999/12/02 07:19:10 $Revision: r11
ros/1 PATCH_11.00 (PHKL_20315)
/usr/conf/lib/libhp-ux.a(lw_scall.o):
lw_scall.s $Date: 2002/01/01 19:12:23 $Revision: r11
ros/13 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_clockint.o):
pm_clockint.c $Date: 2002/01/01 19:11:33 $Revision:
r11ros/9 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_policy.o):
pm_policy.c $Date: 2001/04/05 18:18:43 $Revision: r1
1ros/20 PATCH_11.00 (PHKL_23617)
/usr/conf/lib/libhp-ux.a(pm_proc.o):
pm_proc.c $Date: 2002/01/01 19:09:09 $Revision: r11r
os/16 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_signal.o):
pm_signal.c $Date: 2002/01/01 19:09:57 $Revision: r1
1ros/19 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(pm_swtch.o):
pm_swtch.c $Date: 2001/08/14 15:43:42 $Revision: r11
ros/29 PATCH_11.00 (PHKL_24943)
/usr/conf/lib/libhp-ux.a(pm_threads.o):
pm_threads.c $Date: 2002/01/01 19:10:42 $Revision: r
11ros/21 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(qmml.o):
qmml.s $Date: 2000/11/21 12:30:35 $Revision: r11ros/
1 PATCH_11.00 (PHKL_22796)
/usr/conf/lib/libhp-ux.a(scall_stubs.o):
scall_stubs.s $Date: 2002/01/01 19:17:27 $Revision:
r11ros/4 PATCH_11.00 (PHKL_25999)
/usr/conf/lib/libhp-ux.a(subr_ksleep.o):
subr_ksleep.c $Date: 2001/10/16 07:31:33 $Revision:
r11ros/10 PATCH_11.00 (PHKL_25475)
/usr/conf/lib/libhp-ux.a(subr_threads.o):
subr_threads.c $Date: 2001/08/14 15:43:42 $Revision:
r11ros/17 PATCH_11.00 (PHKL_24943)
/usr/conf/lib/libhp-ux.a(sys_gen.o):
sys_gen.c $Date: 2001/08/14 15:43:42 $Revision: r11r
os/13 PATCH_11.00 (PHKL_24943)
/usr/conf/lib/libhp-ux.a(vfs.o):
vfs.c $Date: 2000/10/16 10:32:49 $Revision: r11ros/6
PATCH_11.00 (PHKL_22517)
/usr/conf/lib/libhp-ux.a(vfs_vnode.o):
vfs_vnode.c $Date: 2000/03/17 11:52:36 $Revision: r1
1ros/5 PATCH_11.00 (PHKL_21361)
/usr/conf/lib/libprm.a(kern_fss.o):
kern_fss.c $Date: 1999/09/14 09:27:43 $Revision: r11
ros/5 PATCH_11.00 (PHKL_19873)
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP:
/usr/conf/space.h.d/core-hpux.h:
core-hpux.h $Date: 2001/10/16 07:36:20 $Revision: r1
1ros/11 PATCH_11.00 (PHKL_25475)
cksum(1) Output:
OS-Core.CORE-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP:
1964822114 5550 /usr/conf/h/fss.h
1552822860 40438 /usr/conf/h/unistd.h
ProgSupport.C-INC,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP:
1964822114 5550 /usr/include/sys/fss.h
179451922 5533 /usr/include/sys/ksleep.h
1552822860 40438 /usr/include/sys/unistd.h
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP:
1940051102 25312 /usr/conf/lib/libhp-ux.a(autosysgen.o)
383245177 7356 /usr/conf/lib/libhp-ux.a(gateway.o)
362749981 34628 /usr/conf/lib/libhp-ux.a(init_sent.o)
596034258 19940 /usr/conf/lib/libhp-ux.a(kern_fork.o)
3190560137 18632 /usr/conf/lib/libhp-ux.a(kern_sig.o)
3354832684 5584 /usr/conf/lib/libhp-ux.a(lo_subr.o)
1642108747 3796 /usr/conf/lib/libhp-ux.a(lo_vfsops.o)
3937685015 6712 /usr/conf/lib/libhp-ux.a(lo_vnops.o)
4243205337 10172 /usr/conf/lib/libhp-ux.a(lw_scall.o)
2067795593 6672 /usr/conf/lib/libhp-ux.a(pm_clockint.o)
692171038 28672 /usr/conf/lib/libhp-ux.a(pm_policy.o)
2980136930 25764 /usr/conf/lib/libhp-ux.a(pm_proc.o)
3002725877 30424 /usr/conf/lib/libhp-ux.a(pm_signal.o)
3747982730 34300 /usr/conf/lib/libhp-ux.a(pm_swtch.o)
3698235870 26540 /usr/conf/lib/libhp-ux.a(pm_threads.o)
980263663 4096 /usr/conf/lib/libhp-ux.a(qmml.o)
3792698067 1500 /usr/conf/lib/libhp-ux.a(scall_stubs.o)
425445199 12744 /usr/conf/lib/libhp-ux.a(subr_ksleep.o)
2236735189 28388 /usr/conf/lib/libhp-ux.a(subr_threads.o)
3792222977 16828 /usr/conf/lib/libhp-ux.a(sys_gen.o)
4195385606 25012 /usr/conf/lib/libhp-ux.a(vfs.o)
2503384681 11772 /usr/conf/lib/libhp-ux.a(vfs_vnode.o)
2038085197 15888 /usr/conf/lib/libprm.a(kern_fss.o)
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_32,v=HP:
3114508912 21673 /usr/conf/space.h.d/core-hpux.h
OS-Core.CORE2-KRN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP:
2552864451 166864 /usr/conf/lib/libhp-ux.a(autosysgen.o)
1781791867 45968 /usr/conf/lib/libhp-ux.a(gateway.o)
2625507518 134344 /usr/conf/lib/libhp-ux.a(init_sent.o)
2766875961 44072 /usr/conf/lib/libhp-ux.a(kern_fork.o)
386444817 50160 /usr/conf/lib/libhp-ux.a(kern_sig.o)
1994974225 14688 /usr/conf/lib/libhp-ux.a(lo_subr.o)
2464395949 8776 /usr/conf/lib/libhp-ux.a(lo_vfsops.o)
213328873 19184 /usr/conf/lib/libhp-ux.a(lo_vnops.o)
4110907358 15632 /usr/conf/lib/libhp-ux.a(lw_scall.o)
76095785 15128 /usr/conf/lib/libhp-ux.a(pm_clockint.o)
24909754 69880 /usr/conf/lib/libhp-ux.a(pm_policy.o)
2085240165 64952 /usr/conf/lib/libhp-ux.a(pm_proc.o)
2696910611 69384 /usr/conf/lib/libhp-ux.a(pm_signal.o)
634536830 73240 /usr/conf/lib/libhp-ux.a(pm_swtch.o)
3438004132 60976 /usr/conf/lib/libhp-ux.a(pm_threads.o)
3832579934 5880 /usr/conf/lib/libhp-ux.a(qmml.o)
3017245883 135376 /usr/conf/lib/libhp-ux.a(scall_stubs.o)
1346470399 30816 /usr/conf/lib/libhp-ux.a(subr_ksleep.o)
3897604752 67360 /usr/conf/lib/libhp-ux.a(subr_threads.o)
2629078952 37336 /usr/conf/lib/libhp-ux.a(sys_gen.o)
3326202070 66296 /usr/conf/lib/libhp-ux.a(vfs.o)
391041071 25232 /usr/conf/lib/libhp-ux.a(vfs_vnode.o)
945370745 37272 /usr/conf/lib/libprm.a(kern_fss.o)
OS-Core.KERN2-RUN,fr=B.11.00,fa=HP-UX_B.11.00_64,v=HP:
3085861437 22292 /usr/conf/space.h.d/core-hpux.h
Patch Conflicts: None
Patch Dependencies:
s700: 11.00: PHKL_18543
s800: 11.00: PHKL_18543
Hardware Dependencies: None
Other Dependencies:
PHKL_25999: To enable the pthread shared mutex performance
enhancement, three patches (PHKL_25998, PHKL_25999, and
PHCO_26000) are required.
To enable the storage of large command lines in the kernel,
two patches (PHKL_25999 and PHKL_26008) are required.
PHKL_23617, PHKL_23842: Six patches work together to
implement this change (PHKL_23617, PHKL_23842, PHKL_20943,
PHKL_20944, PHKL_20945, and PHKL_21024) to reduce dispatch
latency for higher priority runnable threads. These patches
may be installed in any order or combination, or not at all
(if the reduced dispatch latency feature is not desired).
PHKL_23406, PHKL_23407: If NFS is installed on the system,
all five patches (PHNE_23249, PHKL_23406, PHKL_23407,
PHKL_23408, PHKL_23409) are required to resolve the process
hang/deadlock due to unkillable processes executed over NFS.
However, if NFS is not in use, none of these patches are
required. All five of these patches may be installed
independently. If fewer than four out of the four PHKL
patches are installed the P_NOSTOP feature will not be
enabled.
Supersedes:
PHKL_24733 PHKL_23842 PHKL_23407 PHKL_23226 PHKL_23001 PHKL_22940
PHKL_22796 PHKL_22568 PHKL_22145 PHKL_21830 PHKL_21608 PHKL_21361
PHKL_21348 PHKL_20942 PHKL_20625 PHKL_20315 PHKL_20245 PHKL_20236
PHKL_20202 PHKL_19930 PHKL_19531 PHKL_15689 PHKL_14750 PHKL_14493
PHKL_14119 PHKL_13290 PHKL_24752 PHKL_23955 PHKL_23002 PHKL_25475
PHKL_24943 PHKL_24753 PHKL_24734 PHKL_24502 PHKL_23617 PHKL_23408
PHKL_23180 PHKL_22589 PHKL_22517 PHKL_22142 PHKL_21832 PHKL_21111
PHKL_20941 PHKL_20883 PHKL_20659 PHKL_20399 PHKL_20349 PHKL_19873
Equivalent Patches: None
Patch Package Size: 1920 KBytes
Installation Instructions:
Please review all instructions and the Hewlett-Packard
SupportLine User Guide or your Hewlett-Packard support terms
and conditions for precautions, scope of license,
restrictions, and, limitation of liability and warranties,
before installing this patch.
------------------------------------------------------------
1. Back up your system before installing a patch.
2. Login as root.
3. Copy the patch to the /tmp directory.
4. Move to the /tmp directory and unshar the patch:
cd /tmp
sh PHKL_25999
5. Run swinstall to install the patch:
swinstall -x autoreboot=true -x patch_match_target=true \
-s /tmp/PHKL_25999.depot
By default swinstall will archive the original software in
/var/adm/sw/save/PHKL_25999. If you do not wish to retain a
copy of the original software, include the patch_save_files
option in the swinstall command above:
-x patch_save_files=false
WARNING: If patch_save_files is false when a patch is installed,
the patch cannot be deinstalled. Please be careful
when using this feature.
For future reference, the contents of the PHKL_25999.text file is
available in the product readme:
swlist -l product -a readme -d @ /tmp/PHKL_25999.depot
To put this patch on a magnetic tape and install from the
tape drive, use the command:
dd if=/tmp/PHKL_25999.depot of=/dev/rmt/0m bs=2k
Special Installation Instructions:
This patch depends on base patch PHKL_18543.
For successful installation please insure that PHKL_18543
is already installed, or that PHKL_18543 is included
in the same depot with this patch and PHKL_18543
is selected for installation.
|
Printable version
