Error Propagation Analysis File Systems
[www.cs.wisc.edu] [research.cs.wisc.edu] [pages.cs.wisc.edu] [www.cs.wisc.edu] [www.cs.wisc.edu] [www.eecs.berkeley.edu] [pages.cs.wisc.edu] [people.cs.uchicago.edu] [web.cs.ucdavis.edu] [www.eecs.berkeley.edu] Save to List Add to Collection Correct Errors Monitor Changes by Cindy Rubio-gonzález , Haryadi S. Gunawi , Ben Liblit , Remzi H. Arpaci-dusseau , Andrea C. Arpaci-dusseau Venue:In Proceedings of the ACM SIGPLAN 2009 Conference on Programming Language Design and Implementation Citations:22 - 8 self Summary Citations Active Bibliography Co-citation Clustered Documents Version History BibTeX @INPROCEEDINGS{Rubio-gonzález09errorpropagation,
author = {Cindy Rubio-gonzález and Haryadi S. Gunawi and Ben Liblit and Remzi H. Arpaci-dusseau and Andrea C. Arpaci-dusseau},title = {Error propagation analysis for file systems},booktitle = {In Proceedings of the ACM SIGPLAN 2009 Conference on Programming Language Design and Implementation},year = {2009}} Share OpenURL Abstract Unchecked errors are especially pernicious in operating system file management code. Transient or permanent hardware failures are inevitable, and error-management bugs at the file system layer can cause silent, unrecoverable data corruption. We propose an interprocedural static analysis that tracks errors as they propagate through file system code. Our implementation detects overwritten, out-ofscope, and unsaved unchecked errors. Analysis of four widely-used Linux file system implementations (CIFS, ext3, IBM JFS and ReiserFS), a relatively new file system implementation (ext4), and shared virtual file system (VFS) code uncovers 312 error propagation bugs. Our flow- and context-sensitive approach produces more precise results than related techniques while providing better diagnostic information, including possible execution paths that demonstrate each bug found. Keyphrases error propagation analysis file system unchecked error virtual file system diagnostic information file system layer related technique error propagation bug widely-used linux file system implementation ibm jfs possible executio
all corrupted my inbox, forcing me to restore from backup. How is it that desktop mail clients are less reliable than gmail, even though my gmail account not only handles more email than I ever had on desktop clients, but also allows simultaneous access from multiple locations across the globe? Distributed systems have an unfair advantage, in that they can be robust against total disk failure in a way that desktop clients can’t, but none of the file corruption issues I’ve had have been from total disk failure. Why has my experience with desktop applications been so bad? Well, what sort of failures can occur? Crash consistency (maintaining consistent http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.188.201 state even if there’s a crash) is probably the easiest property to consider, since we can assume that everything, from the filesystem to the disk, works correctly; let’s consider that first. Crash Consistency Pillai et al. had a paper and presentation at OSDI ‘14 on exactly how hard it is to save data without corruption or data loss. Let’s look at a simple example of what it takes to save data in a way https://danluu.com/file-consistency/ that’s robust against a crash. Say we have a file that contains the text a foo and we want to update the file to contain a bar. The pwrite function looks like it’s designed for this exact thing. It takes a file descriptor, what we want to write, a length, and an offset. So we might try pwrite([file], “bar”, 3, 2) // write 3 bytes at offset 2 What happens? If nothing goes wrong, the file will contain a bar, but if there’s a crash during the write, we could get a boo, a far, or any other combination. Note that you may want to consider this an example over sectors or blocks and not chars/bytes. If we want atomicity (so we either end up with a foo or a bar but nothing in between) one standard technique is to make a copy of the data we’re about to change in an undo log file, modify the “real” file, and then delete the log file. If a crash happens, we can recover from the log. We might write something like creat(/dir/log); write(/dir/log, “2,3,foo”, 7); pwrite(/dir/orig, “bar”, 3, 2); unlink(/dir/log); This should allow recovery from a crash without data corruption via the undo log, at least if we’re using ext3 and we made sure to mount our drive with data=jou
Request full-text Defective error/pointer interactions in the Linux kernelConference Paper · January 2011 with 51 ReadsDOI: 10.1145/2001420.2001434 · Source: DBLPConference: Proceedings of the https://www.researchgate.net/publication/220854453_Defective_errorpointer_interactions_in_the_Linux_kernel 20th International Symposium on Software Testing and Analysis, ISSTA 2011, Toronto, ON, Canada, July 17-21, 20111st Cindy Rubio-González2nd Ben LiblitAbstractLinux run-time errors are represented by integer values referred to as error codes. These values propagate across long function- call chains before being handled. As these error codes propagate, they are often temporarily error propagation or permanently encoded into pointer values. Error-valued pointers are not valid memory addresses, and therefore require special care by programmers. Misuse of pointer variables that store error codes can lead to serious problems such as system crashes, data corruption, unexpected results, etc. We use static program analysis to find three classes of bugs error propagation analysis relating to error-valued pointers: bad dereferences, bad pointer arithmetic, and bad overwrites. Our tool finds 56 true bugs among 52 different Linux file system implementations, the virtual file system (VFS), the memory management module (mm), and 4 drivers.Do you want to read the rest of this conference paper?Request full-text CitationsCitations3ReferencesReferences24AntMiner: mining more bugs by reducing noise interference"AntMiner can detect both of them. In the studies of Gunawi et al. [19] and Rubio-Gonzá lez et al. [32], they found that error codes are often incorrectly propagated in file systems, and such bugs are very hard to detect both statically and dynamically . AntMiner provides an effective way to detect this kind of bugs by mining the function return patterns. "Conference Paper · Jan 2016 Bin LiangPan BianYan Zhang+2 more authors ...Yan CaiReadFinding Error-Handling Bugs in Systems Code Using Static Analysis"Misuse of pointer variables that store error codes can lead to serious problems such as system crashes, data
be down. Please try the request again. Your cache administrator is webmaster. Generated Fri, 14 Oct 2016 15:28:26 GMT by s_wx1131 (squid/3.5.20)