The Year 2038 problem relates to the time represented in many digital systems as the number of seconds passed since January 1, 1970 and stores them as signed 32-bit integers. Such an implementation can not encode the time after 03:14:07 UTC on January 19, 2038. Similar to Y2K problem, Year 2038 problem is caused by insufficient capacity of storage unit selected.
Video Year 2038 problem
Technical causes
The last time that can be represented in 32-bit Unix integer time format is 03:14:07 UTC on Tuesday, January 19, 2038 (2 31 -1 = 2,147,483,647 seconds after January 1, 1970). The time outside it will wrap and be stored internally as a negative number, which will be interpreted by this system on December 13, 1901 instead of January 19, 2038. This is caused by an overflow of integers. The counter runs out of usable bit digits, flips the bit mark instead, and reports the maximum negative number (keep counting up , towards zero). Generating incorrect calculations on the system tends to cause problems for users and other lean parties.
Programs that work with dates in the future will start experiencing problems more quickly; for example a program that works with 20 years in the future must have been fixed by January 19, 2018.
Maps Year 2038 problem
Initial problem
In May 2006, the report emerged from the initial manifestation of the Y2038 problem in the AOLserver software. This software is designed with kludge to handle database requests that should "never". Instead of handling this particular case specifically, the initial design just sets a changeable time-out date in the future. The default configuration for the server states that the request will run out after a billionth of a second. One billionth of a second (about 32 years) after 01: 27: 28 UTC on May 13, 2006 (May 12, 2006 in America) is out of date 2038. Thus, after this time, the time-out calculation overflows and returns the actual date in the past, caused the software to freeze. When a problem is found, the AOLServer operator must edit the configuration file and set the time-out to a lower value.
Game players or apps programmed to implement a waiting period will experience this issue as they attempt to address the waiting period on devices that store the code, manually setting their devices (such as Nexus 7) to date after January 19, 2038, but can not do so, because 32-bit Unix time format is in use.
Vulnerable system
Embedded systems that use dates for counting or logging diagnostics will most likely be affected by the 2038 bug.
Many transport systems from flight to car use embedded systems extensively. In automotive systems, this may include anti-lock braking (ABS) systems, electronic stability control (ESC/ESP), traction control (TCS) and automated four-wheel drive; The aircraft may use an inertial guide system and a GPS receiver. However, this does not mean that all of these systems will experience bugs. Many such systems will not require access to date. For those who do, a system that only tracks the difference between the time/date and not the absolute time/date will, by the nature of the calculation, have no problem. This is the case for automotive diagnostics based on legislative standards such as CARB (California Air Resources Board).
Another major use of embedded systems is in communication devices, including cell phones and Internet equipment (routers, wireless access points, etc.) that rely on accurate time and date storage and are increasingly based on UNIX-like operating systems. For example, a bug makes some Android devices crash and does not restart when time is changed to that date.
Despite the modern generation update of 18-24 months in computer system technology, embedded systems are designed to last a lifetime of machines in which they are components. It is conceivable that some of these systems can still be used in 2038. It may be impractical or, in some cases, impossible to update the software running this system, which in turn requires replacement if 32-bit time_t limitations must be fixed.
The built-in MySQL database functions such as UNIX_TIMESTAMP () will return 0 after 03:14:07 UTC on January 19, 2038, although bug fixes are donated on March 22, 2017.
Data structure with timing issue
Many of the data structures used today have 32-bit timing representations embedded in their structure. The complete list of data structures is almost impossible to obtain but there is a well known data structure that has Unix timing issues:
- system files (many file systems use only 32 bits to represent time in the inode)
- binary file format (which uses 32-bit time fields)
- database (which has a 32-bit time field)
- the database query language, such as SQL that has UNIX_TIMESTAMP () like the command
Examples of systems that use data structures that may contain 32-bit time representations include:
- embedded factory, refinery control and monitoring subsystem
- various medical devices
- various military devices
Any system that uses a data structure containing a 32-bit time representation will present a risk. The level of risk depends on the failure mode.
NTP time stamp
The Network Time Protocol has an associated overflow problem, which manifests itself in 2036 instead of 2038. The 64-bit timestamp used by NTP consists of 32-bit sections for seconds and 32-bit sections for fractional seconds, giving NTP a rolling time scale each 2 32 seconds (136 years) and theoretical resolution 2 -32 seconds (233 picoseconds). NTP uses the time of January 1, 1900. The first rollover occurred in 2036, before the year 2038 UNIX problem.
Implementation should equal NTP time using knowledge of time estimates from other sources. Since the NTP only works with the difference between time stamp and never its absolute value, the cover is not visible in the calculation during the time stamps within 68 years of each other. However, after the cover client can still face 2 issues: 1) They accept the date 01-01-1900 00: 00: 00UTC, not 07 February 2036 06:28:15 (plus minus leap seconds) as the new time; and 2) when a client tries to adopt this time and keeps it in UNIX time format, as many embedded systems do, it will fail because UNIX time starts on December 13, 1901 (signed 32 bit integer) or 01 January 1970 (unsigned 32 bit integers).
This means that for NTP, rollover will not be visible for most of the running systems, as they will have a great time in a very small tolerance. However, a starting system needs to know the date in no more than 68 years. Given the big mistakes that are allowed, it is not expected that this is too burdensome requirements. One of the recommended methods is to set the clock no earlier than the system creation date or release date of the current version of NTP software. Many systems use battery-powered clocks to avoid this problem.
However, the upcoming NTP version can extend the representation time to 128 bits: 64 bits for seconds and 64 bits for fractions of a second. The current NTP4 format has support for Era and Offset Eyes , which when used correctly will help fix the rollover issue of dates. According to Mills, "The 64-bit value for the fraction is enough to complete the amount of time it takes for photons to pass the electrons at the speed of light.The value of 64 bits a second is enough to give an unambiguous time representation until the universe goes away."
Possible solutions
There is no universal solution to the problem of 2038. Any changes to the data type definition time_t will result in code compatibility issues in any app where the date and time representation depends on the 32-bit time_t character marked integer. For example, changing the time_t to an unsigned 32-bit integer, which will extend the range to 2106, will affect programs that store, retrieve, or manipulate dates before 1970, since that date is represented by a negative number. Increasing the time_t size to 64-bit in existing systems will cause incompatible changes to the layout of the structure and interface of the binary function.
Also there is no universal solution to the problem with real time transmission date of DVB and ATSC due to problems with legacy recipients. The problem remains to be recognized or resolved by one of the organizations. The only solution is to stop all time-related metadata services such as programming guides and automatic date syncing after the affected date. One possible option would be to create a new table type for the affected part of the specification and use the ISO 8601 date string instead of the fixed integer - as used in the ISO 9660 and ISO 13346 filesystems.
Most operating systems designed to run on 64-bit devices already use signed signed signed time_t integer numbers. Using signed 64-bit values ​​introduces a new cover date that is more than twenty times greater than the estimated age of the universe: about 292 billion years from now, at 15:30:08 UTC on Sunday, December 4, 292.277.026.596. The ability to make calculations on dates is limited by the fact that tm_year uses a 32 bit integer value signed since 1900 for this year. This limits the year to a maximum of 2,147,485,547 (2,147,483,647 1900).
Starting with NetBSD version 6.0 (released in October 2012), the NetBSD operating system uses 64-bit time_t for both 32-bit and 64-bit architectures. Compiled apps for older NetBSD releases with 32-bit time_t are supported via a binary compatibility layer, but older apps like that will still run into Year 2038 issues.
OpenBSD since version 5.5, released in May 2014, also uses 64-bit time_t for both 32-bit and 64-bit architectures. Unlike NetBSD, there is no binary compatibility layer. Therefore, apps that expect 32-bit time_t and apps that use something different from time_t to save time values ​​can be corrupted.
Linux uses 64-bit time_t for 64-bit architectures only; Pure 32-bit ABI has not changed due to backward compatibility. There is ongoing work, mostly for embedded Linux systems, to support 64-bit time_t on 32-bit architectures as well.
The x32 ABI for Linux (which defines the environment for programs with 32-bit addresses but runs the processor in 64-bit mode) uses 64-bit time_t . Because it is a new environment, no special matching precautions are required.
Network File System version 4 has defined the timed field as struct nfstime4 {int64_t seconds; uint32_t nseconds;} since December, 2000. The value greater than zero for the second field shows the date after 0 hours, January 1, 1970. The value less than zero for the second field indicates the date before 0-hours, January 1, 1970. In both cases, the nseconds field (nanodec) is added to the second field for the final time representation.
Alternative proposals have been made (some of which are in use), such as storing milliseconds or microseconds since the time (usually January 1, 1970 or January 1, 2000) in a signed 64-bit integer, providing a minimum range of 300,000 years at a microsecond resolution. Other proposals for new time representations provide different sizes, ranges, and sizes (almost always wider than 32 bits), as well as resolve other related issues, such as leap second handling. Specifically, TAI64 is a standard implementation of Temps Atomique International , the current international real time standard for determining terms of reference and second.
See also
- Deep Impact, missing when its internal clock reaches exactly 2 32 a tenth of a second since 2000 on August 11, 2013, 00:38:49 UTC.
- Time formatting and storage bugs
- Unix Time
- Problem 10,000 years
- Year 2000 issue
Note
References
External links
- Login in How It Works Works
- Project 2038 Frequently Asked Questions
- Critical and Significant Date 2038
- 2038-safe replacement for time.h on a 32 bit system
- The number of errors that can cause havoc
- Clewett, James. "2,147,483,647 - End of Time [Unix]". Numberphile . Brady Haran.
Source of the article : Wikipedia
0 Comments