Rabu, 4 Januari 2012

Y2K38 or Y2.038K

Example showing how the date would reset, represented as a signed 32bit integer (at 03:14:08 UTC on 19 January 2038).

Millennium Bug mark II

The Year 2038 Problem is a programming error that may cause important computer software to fail before the year 2038. The event affects all software that store system time as a signed 32-bit integer. These systems interpret time as the number of seconds since Thursday January 1, 1970 and the furthest time that can be represented this way is 03:14:07 UTC on Tuesday, January 19, 2038. All times beyond this moment will wrap around and be stored internally as a negative number, which will cause these 32-bit integer systems to interpret the date as 1901, rather than 2038. This will create erroneous calculations and system failure. Most all 32-bit Unix-like systems store and manipulate time in this format, called Unix time. For this reason, the year 2038 problem is often referred to as the Unix Millennium Bug.

The AOL server software experienced a Unix time problem in 2006 when it was discovered that their server default configuration was set to time out after one billion seconds or approximately 32 years. This caused the system to overflow and return a date that was in the past, ultimately crashing the AOL server. The company was able to fix the problem by editing the configuration file to set the time out to a lower value. However, this was only a temporary fix for AOL. There is currently no straightforward and general solution for the 2038 Unix time problem for existing CPU and operating system combinations. This makes the problem much more serious than the Y2K year 2000 event, in which computer programmers were able to update their systems to avoid failure.

In dealing with the 2038 problem, you can’t simply change the definition of the time data type to a 64-bit setting without breaking binary compatibility for the software. You also can’t change time to an unsigned 32-bit integer without crashing the system. Hundreds of millions of 32-bit systems are deployed around the world. Many of these programs are in important government owned embedded software, which simply can’t be replaced by 2038. Additionally, 32-bit applications running on 64-bit systems are likely to be affected by the issue. Some alternative proposals have been suggested, including storing time in either milliseconds or microseconds. However, to date, no clear solution has been agreed upon and the event remains a strong concern all over the world.

Year 2038 problem

From Wikipedia, the free encyclopedia

The year 2038 problem (also known as the Unix Millennium Bug[citation needed], Y2K38 or Y2.038K[citation needed] by analogy to the Y2K problem) may cause some computer software to fail at some point near the year 2038. The problem affects all software and systems that both store system time as a signed 32-bit integer, and interpret this number as the number of seconds since 00:00:00 UTC on Thursday, 1 January 1970.[1] The furthest time that can be represented this way is 03:14:07 UTC on Tuesday, 19 January 2038.[2] Times beyond this moment will "wrap around" and be stored internally as a negative number, which these systems will interpret as a date in 1901 rather than 2038. This is caused by integer overflow. The counter "runs out" of usable digits, "increments" the sign bit instead, and reports a maximally negative number (continuing to count up, toward zero). This will likely cause problems for users of these systems due to erroneous calculations.

Further, while most programs will only be affected in or very close to 2038, programs that work with future dates will begin to run into problems much sooner. For example, a program that works with dates 20 years in the future will have to be fixed no later than in 2018.

Because most 32-bit Unix-like systems store and manipulate time in this format, it is usually called Unix time, and so the year 2038 problem is often referred to as the Unix Millennium Bug.

Early problems
In May 2006, reports surfaced of an early manifestation of the Y2038 problem in the AOLserver software. The software was designed with a kludge to handle a database request that should "never" time out. Rather than specifically handling this special case, the initial design simply specified an arbitrary time-out date in the future. The default configuration for the server specified that the request should time out after one billion seconds. One billion seconds (approximately thirty-two years) after 9:27.28 pm on 12 May 2006 is beyond the 2038 cutoff date. Thus, after this time, the time-out calculation overflowed and returned a date that was actually in the past, causing the software to crash. When the problem was discovered, AOL server managers had to edit the configuration file and set the time-out to a lower value.[3][4]

Vulnerable systems
Embedded systems are most likely to be affected by the 2038 bug. Telecommunication systems and transportation systems from flight to automobiles increasingly use embedded systems. Automobiles, electric vehicles, and hybrid vehicles are increasingly using embedded systems to maximize efficiency and reduce pollution. Other automotive safety systems include anti-lock braking system (ABS), electronic stability control (ESC/ESP), traction control (TCS) and automatic four-wheel drive. New aircraft contain advanced avionics such as inertial guidance systems and GPS receivers that also have considerable safety requirements. Another major use of embedded systems is in communications devices, including cell phones and Internet appliances (routers, wireless access points, etc.) which rely on storing an accurate time and date and are increasingly based on subsets of UNIX (Android, Apple iOS, "light" versions of Linux, etc.).

As of 2011, most embedded systems use 8-bit or 16-bit microprocessors, even as desktop systems are transitioning to 64-bit systems. Despite the modern 18–24-month generational update in computer systems technology, embedded systems are designed to last the lifetime of the machine in which they are a component. It is conceivable that some of these systems may still be in use in 2038. It may be impractical or, in some cases, impossible to upgrade the software running these systems, ultimately requiring replacement if 32-bit time_t limitations are to be corrected.

The use of 32-bit time_t has also been encoded into some file formats[citation needed], which means it can live on well beyond the life of the machines on which such file formats were originally supported.

Data structures with time problems
Many data structures in use today have 32-bit time representations embedded into their structure. A full list of these data structures is impossible to derive but there are well-known data structures that have the Unix time problem.

file systems (like many inode file systems still in use)
databases (that have 32-bit time fields)
COBOL databases from the 1970s, 1980s and 1990s that have not been replaced by 2038-compliant systems
embedded factory, refinery control and monitoring subsystems
assorted medical devices
assorted military devices

Each one of these places where data structures using 32-bit time are in place has its own risks related to failure of the product to perform as designed.


There is no universal solution for the Year 2038 problem. Any change to the definition of the time_t data type would result in code compatibility problems in any application in which date and time representations are dependent on the nature of the signed 32-bit time_t integer. For example, changing time_t to an unsigned 32-bit integer, which would extend the range to the year 2106, would adversely affect programs that store, retrieve, or manipulate dates prior to 1970, as such dates are represented by negative numbers.

Most operating systems designed to run on 64-bit hardware already use signed 64-bit time_t integers, effectively eliminating the Year 2038 problem in any software that has been developed to use the extended format. Using a signed 64-bit value introduces a new wraparound date that is over twenty times greater than the theorized age of the universe: approximately 292 billion years from now, at 15:30:08 on Sunday, 4 December 292,277,026,596. The ability to make computations on dates is limited by the fact that struct tm uses a signed 32 bit int value for the year. This limits the year to a maximum of 2,147,485,547.

Alternative proposals have been made (some of which are in use), such as storing either milliseconds or microseconds since an epoch (typically either 1 January 1970 or 1 January 2000) in a signed-64 bit integer, providing a minimum of 300,000 years range.[5][6] Other proposals for new time representations provide different precisions, ranges, and sizes (almost always wider than 32 bits), as well as solving other related problems, such as the handling of leap seconds.

Tiada ulasan:

Catat Ulasan