/** * compress.c - Compressed attribute handling code. Originated from the Linux-NTFS * project. * * Copyright (c) 2004-2005 Anton Altaparmakov * Copyright (c) 2004-2006 Szabolcs Szakacsits * Copyright (c) 2005 Yura Pakhuchiy * Copyright (c) 2009-2010 Jean-Pierre Andre * * This program/include file is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program/include file is distributed in the hope that it will be * useful, but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program (in the main directory of the NTFS-3G * distribution in the file COPYING); if not, write to the Free Software * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * A part of the compression algorithm is based on lzhuf.c whose header * describes the roles of the original authors (with no apparent copyright * notice, and according to http://home.earthlink.net/~neilbawd/pall.html * this was put into public domain in 1988 by Haruhiko OKUMURA). * * LZHUF.C English version 1.0 * Based on Japanese version 29-NOV-1988 * LZSS coded by Haruhiko OKUMURA * Adaptive Huffman Coding coded by Haruyasu YOSHIZAKI * Edited and translated to English by Kenji RIKITAKE */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef HAVE_STDIO_H #include #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #include "attrib.h" #include "debug.h" #include "volume.h" #include "types.h" #include "layout.h" #include "runlist.h" #include "compress.h" #include "lcnalloc.h" #include "logging.h" #include "misc.h" /** * enum ntfs_compression_constants - constants used in the compression code */ typedef enum { /* Token types and access mask. */ NTFS_SYMBOL_TOKEN = 0, NTFS_PHRASE_TOKEN = 1, NTFS_TOKEN_MASK = 1, /* Compression sub-block constants. */ NTFS_SB_SIZE_MASK = 0x0fff, NTFS_SB_SIZE = 0x1000, NTFS_SB_IS_COMPRESSED = 0x8000, } ntfs_compression_constants; #define THRESHOLD 3 /* minimal match length for compression */ #define NIL NTFS_SB_SIZE /* End of tree's node */ struct COMPRESS_CONTEXT { const unsigned char *inbuf; unsigned int len; unsigned int nbt; int match_position; unsigned int match_length; u16 lson[NTFS_SB_SIZE + 1]; u16 rson[NTFS_SB_SIZE + 257]; u16 dad[NTFS_SB_SIZE + 1]; } ; /* * Initialize the match tree */ static void ntfs_init_compress_tree( struct COMPRESS_CONTEXT *pctx ) { int i; for ( i = NTFS_SB_SIZE + 1; i <= NTFS_SB_SIZE + 256; i++ ) pctx->rson[i] = NIL; /* root */ for ( i = 0; i < NTFS_SB_SIZE; i++ ) pctx->dad[i] = NIL; /* node */ } /* * Insert a new node into match tree for quickly locating * further similar strings */ static void ntfs_new_node ( struct COMPRESS_CONTEXT *pctx, unsigned int r ) { unsigned int pp; BOOL less; BOOL done; const unsigned char *key; int c; unsigned long mxi; unsigned int mxl; mxl = ( 1 << ( 16 - pctx->nbt ) ) + 2; less = FALSE; done = FALSE; key = &pctx->inbuf[r]; pp = NTFS_SB_SIZE + 1 + key[0]; pctx->rson[r] = pctx->lson[r] = NIL; pctx->match_length = 0; do { if ( !less ) { if ( pctx->rson[pp] != NIL ) pp = pctx->rson[pp]; else { pctx->rson[pp] = r; pctx->dad[r] = pp; done = TRUE; } } else { if ( pctx->lson[pp] != NIL ) pp = pctx->lson[pp]; else { pctx->lson[pp] = r; pctx->dad[r] = pp; done = TRUE; } } if ( !done ) { register unsigned long i; register const unsigned char *p1, *p2; i = 1; mxi = NTFS_SB_SIZE - r; if ( mxi < 2 ) less = FALSE; else { p1 = key; p2 = &pctx->inbuf[pp]; /* this loop has a significant impact on performances */ do { } while ( ( p1[i] == p2[i] ) && ( ++i < mxi ) ); less = ( i < mxi ) && ( p1[i] < p2[i] ); } if ( i >= THRESHOLD ) { if ( i > pctx->match_length ) { pctx->match_position = r - pp + 2 * NTFS_SB_SIZE - 1; if ( ( pctx->match_length = i ) > mxl ) { i = pctx->rson[pp]; pctx->rson[r] = i; pctx->dad[i] = r; i = pctx->lson[pp]; pctx->lson[r] = i; pctx->dad[i] = r; i = pctx->dad[pp]; pctx->dad[r] = i; if ( pctx->rson[i] == pp ) pctx->rson[i] = r; else pctx->lson[i] = r; /* remove pp */ pctx->dad[pp] = NIL; done = TRUE; pctx->match_length = mxl; } } else if ( ( i == pctx->match_length ) && ( ( c = ( r - pp + 2 * NTFS_SB_SIZE - 1 ) ) < pctx->match_position ) ) pctx->match_position = c; } } } while ( !done ); } /* * Search for the longest previous string matching the * current one * * Returns the end of the longest current string which matched * or zero if there was a bug */ static unsigned int ntfs_nextmatch( struct COMPRESS_CONTEXT *pctx, unsigned int rr, int dd ) { unsigned int bestlen = 0; do { rr++; if ( pctx->match_length > 0 ) pctx->match_length--; if ( !pctx->len ) { ntfs_log_error( "compress bug : void run\n" ); goto bug; } if ( --pctx->len ) { if ( rr >= NTFS_SB_SIZE ) { ntfs_log_error( "compress bug : buffer overflow\n" ); goto bug; } if ( ( ( rr + bestlen ) < NTFS_SB_SIZE ) ) { while ( ( unsigned int )( 1 << pctx->nbt ) <= ( rr - 1 ) ) pctx->nbt++; ntfs_new_node( pctx, rr ); if ( pctx->match_length > bestlen ) bestlen = pctx->match_length; } else if ( dd > 0 ) { rr += dd; if ( ( int )pctx->match_length > dd ) pctx->match_length -= dd; else pctx->match_length = 0; if ( ( int )pctx->len < dd ) { ntfs_log_error( "compress bug : run overflows\n" ); goto bug; } pctx->len -= dd; dd = 0; } } } while ( dd-- > 0 ); return ( rr ); bug : return ( 0 ); } /* * Compress an input block * * Returns the size of the compressed block (including header) * or zero if there was an error */ static unsigned int ntfs_compress_block( const char *inbuf, unsigned int size, char *outbuf ) { struct COMPRESS_CONTEXT *pctx; char *ptag; int dd; unsigned int rr; unsigned int last_match_length; unsigned int q; unsigned int xout; unsigned int ntag; pctx = ( struct COMPRESS_CONTEXT* )malloc( sizeof( struct COMPRESS_CONTEXT ) ); if ( pctx ) { pctx->inbuf = ( const unsigned char* )inbuf; ntfs_init_compress_tree( pctx ); xout = 2; ntag = 0; ptag = &outbuf[xout++]; *ptag = 0; rr = 0; pctx->nbt = 4; pctx->len = size; pctx->match_length = 0; ntfs_new_node( pctx, 0 ); do { if ( pctx->match_length > pctx->len ) pctx->match_length = pctx->len; if ( pctx->match_length < THRESHOLD ) { pctx->match_length = 1; if ( ntag >= 8 ) { ntag = 0; ptag = &outbuf[xout++]; *ptag = 0; } outbuf[xout++] = inbuf[rr]; ntag++; } else { while ( ( unsigned int )( 1 << pctx->nbt ) <= ( rr - 1 ) ) pctx->nbt++; q = ( pctx->match_position << ( 16 - pctx->nbt ) ) + pctx->match_length - THRESHOLD; if ( ntag >= 8 ) { ntag = 0; ptag = &outbuf[xout++]; *ptag = 0; } *ptag |= 1 << ntag++; outbuf[xout++] = q & 255; outbuf[xout++] = ( q >> 8 ) & 255; } last_match_length = pctx->match_length; dd = last_match_length; if ( dd-- > 0 ) { rr = ntfs_nextmatch( pctx, rr, dd ); if ( !rr ) goto bug; } /* * stop if input is exhausted or output has exceeded * the maximum size. Two extra bytes have to be * reserved in output buffer, as 3 bytes may be * output in a loop. */ } while ( ( pctx->len > 0 ) && ( rr < size ) && ( xout < ( NTFS_SB_SIZE + 2 ) ) ); /* uncompressed must be full size, so accept if better */ if ( xout < ( NTFS_SB_SIZE + 2 ) ) { outbuf[0] = ( xout - 3 ) & 255; outbuf[1] = 0xb0 + ( ( ( xout - 3 ) >> 8 ) & 15 ); } else { memcpy( &outbuf[2], inbuf, size ); if ( size < NTFS_SB_SIZE ) memset( &outbuf[size+2], 0, NTFS_SB_SIZE - size ); outbuf[0] = 0xff; outbuf[1] = 0x3f; xout = NTFS_SB_SIZE + 2; } free( pctx ); } else { xout = 0; errno = ENOMEM; } return ( xout ); /* 0 for an error, > size if cannot compress */ bug : return ( 0 ); } /** * ntfs_decompress - decompress a compression block into an array of pages * @dest: buffer to which to write the decompressed data * @dest_size: size of buffer @dest in bytes * @cb_start: compression block to decompress * @cb_size: size of compression block @cb_start in bytes * * This decompresses the compression block @cb_start into the destination * buffer @dest. * * @cb_start is a pointer to the compression block which needs decompressing * and @cb_size is the size of @cb_start in bytes (8-64kiB). * * Return 0 if success or -EOVERFLOW on error in the compressed stream. */ static int ntfs_decompress( u8 *dest, const u32 dest_size, u8 *const cb_start, const u32 cb_size ) { /* * Pointers into the compressed data, i.e. the compression block (cb), * and the therein contained sub-blocks (sb). */ u8 *cb_end = cb_start + cb_size; /* End of cb. */ u8 *cb = cb_start; /* Current position in cb. */ u8 *cb_sb_start = cb; /* Beginning of the current sb in the cb. */ u8 *cb_sb_end; /* End of current sb / beginning of next sb. */ /* Variables for uncompressed data / destination. */ u8 *dest_end = dest + dest_size; /* End of dest buffer. */ u8 *dest_sb_start; /* Start of current sub-block in dest. */ u8 *dest_sb_end; /* End of current sb in dest. */ /* Variables for tag and token parsing. */ u8 tag; /* Current tag. */ int token; /* Loop counter for the eight tokens in tag. */ ntfs_log_trace( "Entering, cb_size = 0x%x.\n", ( unsigned )cb_size ); do_next_sb: ntfs_log_debug( "Beginning sub-block at offset = %d in the cb.\n", ( int )( cb - cb_start ) ); /* * Have we reached the end of the compression block or the end of the * decompressed data? The latter can happen for example if the current * position in the compression block is one byte before its end so the * first two checks do not detect it. */ if ( cb == cb_end || !le16_to_cpup( ( le16* )cb ) || dest == dest_end ) { ntfs_log_debug( "Completed. Returning success (0).\n" ); return 0; } /* Setup offset for the current sub-block destination. */ dest_sb_start = dest; dest_sb_end = dest + NTFS_SB_SIZE; /* Check that we are still within allowed boundaries. */ if ( dest_sb_end > dest_end ) goto return_overflow; /* Does the minimum size of a compressed sb overflow valid range? */ if ( cb + 6 > cb_end ) goto return_overflow; /* Setup the current sub-block source pointers and validate range. */ cb_sb_start = cb; cb_sb_end = cb_sb_start + ( le16_to_cpup( ( le16* )cb ) & NTFS_SB_SIZE_MASK ) + 3; if ( cb_sb_end > cb_end ) goto return_overflow; /* Now, we are ready to process the current sub-block (sb). */ if ( !( le16_to_cpup( ( le16* )cb ) & NTFS_SB_IS_COMPRESSED ) ) { ntfs_log_debug( "Found uncompressed sub-block.\n" ); /* This sb is not compressed, just copy it into destination. */ /* Advance source position to first data byte. */ cb += 2; /* An uncompressed sb must be full size. */ if ( cb_sb_end - cb != NTFS_SB_SIZE ) goto return_overflow; /* Copy the block and advance the source position. */ memcpy( dest, cb, NTFS_SB_SIZE ); cb += NTFS_SB_SIZE; /* Advance destination position to next sub-block. */ dest += NTFS_SB_SIZE; goto do_next_sb; } ntfs_log_debug( "Found compressed sub-block.\n" ); /* This sb is compressed, decompress it into destination. */ /* Forward to the first tag in the sub-block. */ cb += 2; do_next_tag: if ( cb == cb_sb_end ) { /* Check if the decompressed sub-block was not full-length. */ if ( dest < dest_sb_end ) { int nr_bytes = dest_sb_end - dest; ntfs_log_debug( "Filling incomplete sub-block with zeroes.\n" ); /* Zero remainder and update destination position. */ memset( dest, 0, nr_bytes ); dest += nr_bytes; } /* We have finished the current sub-block. */ goto do_next_sb; } /* Check we are still in range. */ if ( cb > cb_sb_end || dest > dest_sb_end ) goto return_overflow; /* Get the next tag and advance to first token. */ tag = *cb++; /* Parse the eight tokens described by the tag. */ for ( token = 0; token < 8; token++, tag >>= 1 ) { u16 lg, pt, length, max_non_overlap; register u16 i; u8 *dest_back_addr; /* Check if we are done / still in range. */ if ( cb >= cb_sb_end || dest > dest_sb_end ) break; /* Determine token type and parse appropriately.*/ if ( ( tag & NTFS_TOKEN_MASK ) == NTFS_SYMBOL_TOKEN ) { /* * We have a symbol token, copy the symbol across, and * advance the source and destination positions. */ *dest++ = *cb++; /* Continue with the next token. */ continue; } /* * We have a phrase token. Make sure it is not the first tag in * the sb as this is illegal and would confuse the code below. */ if ( dest == dest_sb_start ) goto return_overflow; /* * Determine the number of bytes to go back (p) and the number * of bytes to copy (l). We use an optimized algorithm in which * we first calculate log2(current destination position in sb), * which allows determination of l and p in O(1) rather than * O(n). We just need an arch-optimized log2() function now. */ lg = 0; for ( i = dest - dest_sb_start - 1; i >= 0x10; i >>= 1 ) lg++; /* Get the phrase token into i. */ pt = le16_to_cpup( ( le16* )cb ); /* * Calculate starting position of the byte sequence in * the destination using the fact that p = (pt >> (12 - lg)) + 1 * and make sure we don't go too far back. */ dest_back_addr = dest - ( pt >> ( 12 - lg ) ) - 1; if ( dest_back_addr < dest_sb_start ) goto return_overflow; /* Now calculate the length of the byte sequence. */ length = ( pt & ( 0xfff >> lg ) ) + 3; /* Verify destination is in range. */ if ( dest + length > dest_sb_end ) goto return_overflow; /* The number of non-overlapping bytes. */ max_non_overlap = dest - dest_back_addr; if ( length <= max_non_overlap ) { /* The byte sequence doesn't overlap, just copy it. */ memcpy( dest, dest_back_addr, length ); /* Advance destination pointer. */ dest += length; } else { /* * The byte sequence does overlap, copy non-overlapping * part and then do a slow byte by byte copy for the * overlapping part. Also, advance the destination * pointer. */ memcpy( dest, dest_back_addr, max_non_overlap ); dest += max_non_overlap; dest_back_addr += max_non_overlap; length -= max_non_overlap; while ( length-- ) *dest++ = *dest_back_addr++; } /* Advance source position and continue with the next token. */ cb += 2; } /* No tokens left in the current tag. Continue with the next tag. */ goto do_next_tag; return_overflow: errno = EOVERFLOW; ntfs_log_perror( "Failed to decompress file" ); return -1; } /** * ntfs_is_cb_compressed - internal function, do not use * * This is a very specialised function determining if a cb is compressed or * uncompressed. It is assumed that checking for a sparse cb has already been * performed and that the cb is not sparse. It makes all sorts of other * assumptions as well and hence it is not useful anywhere other than where it * is used at the moment. Please, do not make this function available for use * outside of compress.c as it is bound to confuse people and not do what they * want. * * Return TRUE on errors so that the error will be detected later on in the * code. Might be a bit confusing to debug but there really should never be * errors coming from here. */ static BOOL ntfs_is_cb_compressed( ntfs_attr *na, runlist_element *rl, VCN cb_start_vcn, int cb_clusters ) { /* * The simplest case: the run starting at @cb_start_vcn contains * @cb_clusters clusters which are all not sparse, thus the cb is not * compressed. */ restart: cb_clusters -= rl->length - ( cb_start_vcn - rl->vcn ); while ( cb_clusters > 0 ) { /* Go to the next run. */ rl++; /* Map the next runlist fragment if it is not mapped. */ if ( rl->lcn < LCN_HOLE || !rl->length ) { cb_start_vcn = rl->vcn; rl = ntfs_attr_find_vcn( na, rl->vcn ); if ( !rl || rl->lcn < LCN_HOLE || !rl->length ) return TRUE; /* * If the runs were merged need to deal with the * resulting partial run so simply restart. */ if ( rl->vcn < cb_start_vcn ) goto restart; } /* If the current run is sparse, the cb is compressed. */ if ( rl->lcn == LCN_HOLE ) return TRUE; /* If the whole cb is not sparse, it is not compressed. */ if ( rl->length >= cb_clusters ) return FALSE; cb_clusters -= rl->length; }; /* All cb_clusters were not sparse thus the cb is not compressed. */ return FALSE; } /** * ntfs_compressed_attr_pread - read from a compressed attribute * @na: ntfs attribute to read from * @pos: byte position in the attribute to begin reading from * @count: number of bytes to read * @b: output data buffer * * NOTE: You probably want to be using attrib.c::ntfs_attr_pread() instead. * * This function will read @count bytes starting at offset @pos from the * compressed ntfs attribute @na into the data buffer @b. * * On success, return the number of successfully read bytes. If this number * is lower than @count this means that the read reached end of file or that * an error was encountered during the read so that the read is partial. * 0 means end of file or nothing was read (also return 0 when @count is 0). * * On error and nothing has been read, return -1 with errno set appropriately * to the return code of ntfs_pread(), or to EINVAL in case of invalid * arguments. */ s64 ntfs_compressed_attr_pread( ntfs_attr *na, s64 pos, s64 count, void *b ) { s64 br, to_read, ofs, total, total2; u64 cb_size_mask; VCN start_vcn, vcn, end_vcn; ntfs_volume *vol; runlist_element *rl; u8 *dest, *cb, *cb_pos, *cb_end; u32 cb_size; int err; ATTR_FLAGS data_flags; FILE_ATTR_FLAGS compression; unsigned int nr_cbs, cb_clusters; ntfs_log_trace( "Entering for inode 0x%llx, attr 0x%x, pos 0x%llx, count 0x%llx.\n", ( unsigned long long )na->ni->mft_no, na->type, ( long long )pos, ( long long )count ); data_flags = na->data_flags; compression = na->ni->flags & FILE_ATTR_COMPRESSED; if ( !na || !na->ni || !na->ni->vol || !b || ( ( data_flags & ATTR_COMPRESSION_MASK ) != ATTR_IS_COMPRESSED ) || pos < 0 || count < 0 ) { errno = EINVAL; return -1; } /* * Encrypted attributes are not supported. We return access denied, * which is what Windows NT4 does, too. */ if ( NAttrEncrypted( na ) ) { errno = EACCES; return -1; } if ( !count ) return 0; /* Truncate reads beyond end of attribute. */ if ( pos + count > na->data_size ) { if ( pos >= na->data_size ) { return 0; } count = na->data_size - pos; } /* If it is a resident attribute, simply use ntfs_attr_pread(). */ if ( !NAttrNonResident( na ) ) return ntfs_attr_pread( na, pos, count, b ); total = total2 = 0; /* Zero out reads beyond initialized size. */ if ( pos + count > na->initialized_size ) { if ( pos >= na->initialized_size ) { memset( b, 0, count ); return count; } total2 = pos + count - na->initialized_size; count -= total2; memset( ( u8* )b + count, 0, total2 ); } vol = na->ni->vol; cb_size = na->compression_block_size; cb_size_mask = cb_size - 1UL; cb_clusters = na->compression_block_clusters; /* Need a temporary buffer for each loaded compression block. */ cb = ( u8* )ntfs_malloc( cb_size ); if ( !cb ) return -1; /* Need a temporary buffer for each uncompressed block. */ dest = ( u8* )ntfs_malloc( cb_size ); if ( !dest ) { free( cb ); return -1; } /* * The first vcn in the first compression block (cb) which we need to * decompress. */ start_vcn = ( pos & ~cb_size_mask ) >> vol->cluster_size_bits; /* Offset in the uncompressed cb at which to start reading data. */ ofs = pos & cb_size_mask; /* * The first vcn in the cb after the last cb which we need to * decompress. */ end_vcn = ( ( pos + count + cb_size - 1 ) & ~cb_size_mask ) >> vol->cluster_size_bits; /* Number of compression blocks (cbs) in the wanted vcn range. */ nr_cbs = ( end_vcn - start_vcn ) << vol->cluster_size_bits >> na->compression_block_size_bits; cb_end = cb + cb_size; do_next_cb: nr_cbs--; cb_pos = cb; vcn = start_vcn; start_vcn += cb_clusters; /* Check whether the compression block is sparse. */ rl = ntfs_attr_find_vcn( na, vcn ); if ( !rl || rl->lcn < LCN_HOLE ) { free( cb ); free( dest ); if ( total ) return total; /* FIXME: Do we want EIO or the error code? (AIA) */ errno = EIO; return -1; } if ( rl->lcn == LCN_HOLE ) { /* Sparse cb, zero out destination range overlapping the cb. */ ntfs_log_debug( "Found sparse compression block.\n" ); to_read = min( count, cb_size - ofs ); memset( b, 0, to_read ); ofs = 0; total += to_read; count -= to_read; b = ( u8* )b + to_read; } else if ( !ntfs_is_cb_compressed( na, rl, vcn, cb_clusters ) ) { s64 tdata_size, tinitialized_size; /* * Uncompressed cb, read it straight into the destination range * overlapping the cb. */ ntfs_log_debug( "Found uncompressed compression block.\n" ); /* * Read the uncompressed data into the destination buffer. * NOTE: We cheat a little bit here by marking the attribute as * not compressed in the ntfs_attr structure so that we can * read the data by simply using ntfs_attr_pread(). (-8 * NOTE: we have to modify data_size and initialized_size * temporarily as well... */ to_read = min( count, cb_size - ofs ); ofs += vcn << vol->cluster_size_bits; NAttrClearCompressed( na ); na->data_flags &= ~ATTR_COMPRESSION_MASK; tdata_size = na->data_size; tinitialized_size = na->initialized_size; na->data_size = na->initialized_size = na->allocated_size; do { br = ntfs_attr_pread( na, ofs, to_read, b ); if ( br <= 0 ) { if ( !br ) { ntfs_log_error( "Failed to read an" " uncompressed cluster," " inode %lld offs 0x%llx\n", ( long long )na->ni->mft_no, ( long long )ofs ); errno = EIO; } err = errno; na->data_size = tdata_size; na->initialized_size = tinitialized_size; na->ni->flags |= compression; na->data_flags = data_flags; free( cb ); free( dest ); if ( total ) return total; errno = err; return br; } total += br; count -= br; b = ( u8* )b + br; to_read -= br; ofs += br; } while ( to_read > 0 ); na->data_size = tdata_size; na->initialized_size = tinitialized_size; na->ni->flags |= compression; na->data_flags = data_flags; ofs = 0; } else { s64 tdata_size, tinitialized_size; /* * Compressed cb, decompress it into the temporary buffer, then * copy the data to the destination range overlapping the cb. */ ntfs_log_debug( "Found compressed compression block.\n" ); /* * Read the compressed data into the temporary buffer. * NOTE: We cheat a little bit here by marking the attribute as * not compressed in the ntfs_attr structure so that we can * read the raw, compressed data by simply using * ntfs_attr_pread(). (-8 * NOTE: We have to modify data_size and initialized_size * temporarily as well... */ to_read = cb_size; NAttrClearCompressed( na ); na->data_flags &= ~ATTR_COMPRESSION_MASK; tdata_size = na->data_size; tinitialized_size = na->initialized_size; na->data_size = na->initialized_size = na->allocated_size; do { br = ntfs_attr_pread( na, ( vcn << vol->cluster_size_bits ) + ( cb_pos - cb ), to_read, cb_pos ); if ( br <= 0 ) { if ( !br ) { ntfs_log_error( "Failed to read a" " compressed cluster, " " inode %lld offs 0x%llx\n", ( long long )na->ni->mft_no, ( long long )( vcn << vol->cluster_size_bits ) ); errno = EIO; } err = errno; na->data_size = tdata_size; na->initialized_size = tinitialized_size; na->ni->flags |= compression; na->data_flags = data_flags; free( cb ); free( dest ); if ( total ) return total; errno = err; return br; } cb_pos += br; to_read -= br; } while ( to_read > 0 ); na->data_size = tdata_size; na->initialized_size = tinitialized_size; na->ni->flags |= compression; na->data_flags = data_flags; /* Just a precaution. */ if ( cb_pos + 2 <= cb_end ) *( u16* )cb_pos = 0; ntfs_log_debug( "Successfully read the compression block.\n" ); if ( ntfs_decompress( dest, cb_size, cb, cb_size ) < 0 ) { err = errno; free( cb ); free( dest ); if ( total ) return total; errno = err; return -1; } to_read = min( count, cb_size - ofs ); memcpy( b, dest + ofs, to_read ); total += to_read; count -= to_read; b = ( u8* )b + to_read; ofs = 0; } /* Do we have more work to do? */ if ( nr_cbs ) goto do_next_cb; /* We no longer need the buffers. */ free( cb ); free( dest ); /* Return number of bytes read. */ return total + total2; } /* * Read data from a set of clusters * * Returns the amount of data read */ static u32 read_clusters( ntfs_volume *vol, const runlist_element *rl, s64 offs, u32 to_read, char *inbuf ) { u32 count; int xgot; u32 got; s64 xpos; BOOL first; char *xinbuf; const runlist_element *xrl; got = 0; xrl = rl; xinbuf = inbuf; first = TRUE; do { count = xrl->length << vol->cluster_size_bits; xpos = xrl->lcn << vol->cluster_size_bits; if ( first ) { count -= offs; xpos += offs; } if ( ( to_read - got ) < count ) count = to_read - got; xgot = ntfs_pread( vol->dev, xpos, count, xinbuf ); if ( xgot == ( int )count ) { got += count; xpos += count; xinbuf += count; xrl++; } first = FALSE; } while ( ( xgot == ( int )count ) && ( got < to_read ) ); return ( got ); } /* * Write data to a set of clusters * * Returns the amount of data written */ static s32 write_clusters( ntfs_volume *vol, const runlist_element *rl, s64 offs, s32 to_write, const char *outbuf ) { s32 count; s32 put, xput; s64 xpos; BOOL first; const char *xoutbuf; const runlist_element *xrl; put = 0; xrl = rl; xoutbuf = outbuf; first = TRUE; do { count = xrl->length << vol->cluster_size_bits; xpos = xrl->lcn << vol->cluster_size_bits; if ( first ) { count -= offs; xpos += offs; } if ( ( to_write - put ) < count ) count = to_write - put; xput = ntfs_pwrite( vol->dev, xpos, count, xoutbuf ); if ( xput == count ) { put += count; xpos += count; xoutbuf += count; xrl++; } first = FALSE; } while ( ( xput == count ) && ( put < to_write ) ); return ( put ); } /* * Compress and write a set of blocks * * returns the size actually written (rounded to a full cluster) * or 0 if all zeroes (nothing is written) * or -1 if could not compress (nothing is written) * or -2 if there were an irrecoverable error (errno set) */ static s32 ntfs_comp_set( ntfs_attr *na, runlist_element *rl, s64 offs, u32 insz, const char *inbuf ) { ntfs_volume *vol; char *outbuf; char *pbuf; u32 compsz; s32 written; s32 rounded; unsigned int clsz; u32 p; unsigned int sz; unsigned int bsz; BOOL fail; BOOL allzeroes; /* a single compressed zero */ static char onezero[] = { 0x01, 0xb0, 0x00, 0x00 } ; /* a couple of compressed zeroes */ static char twozeroes[] = { 0x02, 0xb0, 0x00, 0x00, 0x00 } ; /* more compressed zeroes, to be followed by some count */ static char morezeroes[] = { 0x03, 0xb0, 0x02, 0x00 } ; vol = na->ni->vol; written = -1; /* default return */ clsz = 1 << vol->cluster_size_bits; /* may need 2 extra bytes per block and 2 more bytes */ outbuf = ( char* )ntfs_malloc( na->compression_block_size + 2 * ( na->compression_block_size / NTFS_SB_SIZE ) + 2 ); if ( outbuf ) { fail = FALSE; compsz = 0; allzeroes = TRUE; for ( p = 0; ( p < insz ) && !fail; p += NTFS_SB_SIZE ) { if ( ( p + NTFS_SB_SIZE ) < insz ) bsz = NTFS_SB_SIZE; else bsz = insz - p; pbuf = &outbuf[compsz]; sz = ntfs_compress_block( &inbuf[p], bsz, pbuf ); /* fail if all the clusters (or more) are needed */ if ( !sz || ( ( compsz + sz + clsz + 2 ) > na->compression_block_size ) ) fail = TRUE; else { if ( allzeroes ) { /* check whether this is all zeroes */ switch ( sz ) { case 4 : allzeroes = !memcmp( pbuf, onezero, 4 ); break; case 5 : allzeroes = !memcmp( pbuf, twozeroes, 5 ); break; case 6 : allzeroes = !memcmp( pbuf, morezeroes, 4 ); break; default : allzeroes = FALSE; break; } } compsz += sz; } } if ( !fail && !allzeroes ) { /* add a couple of null bytes, space has been checked */ outbuf[compsz++] = 0; outbuf[compsz++] = 0; /* write a full cluster, to avoid partial reading */ rounded = ( ( compsz - 1 ) | ( clsz - 1 ) ) + 1; written = write_clusters( vol, rl, offs, rounded, outbuf ); if ( written != rounded ) { /* * TODO : previously written text has been * spoilt, should return a specific error */ ntfs_log_error( "error writing compressed data\n" ); errno = EIO; written = -2; } } else if ( !fail ) written = 0; free( outbuf ); } return ( written ); } /* * Check the validity of a compressed runlist * The check starts at the beginning of current run and ends * at the end of runlist * errno is set if the runlist is not valid */ static BOOL valid_compressed_run( ntfs_attr *na, runlist_element *rl, BOOL fullcheck, const char *text ) { runlist_element *xrl; const char *err; BOOL ok = TRUE; xrl = rl; while ( xrl->vcn & ( na->compression_block_clusters - 1 ) ) xrl--; err = ( const char* )NULL; while ( xrl->length ) { if ( ( xrl->vcn + xrl->length ) != xrl[1].vcn ) err = "Runs not adjacent"; if ( xrl->lcn == LCN_HOLE ) { if ( ( xrl->vcn + xrl->length ) & ( na->compression_block_clusters - 1 ) ) { err = "Invalid hole"; } if ( fullcheck && ( xrl[1].lcn == LCN_HOLE ) ) { err = "Adjacent holes"; } } if ( err ) { ntfs_log_error( "%s at %s index %ld inode %lld\n", err, text, ( long )( xrl - na->rl ), ( long long )na->ni->mft_no ); errno = EIO; ok = FALSE; err = ( const char* )NULL; } xrl++; } return ( ok ); } /* * Free unneeded clusters after overwriting compressed data * * This generally requires one or two empty slots at the end of runlist, * but we do not want to reallocate the runlist here because * there are many pointers to it. * So the empty slots have to be reserved beforehand * * Returns zero unless some error occurred (described by errno) * * +======= start of block =====+ * 0 |A chunk may overflow | <-- rl usedcnt : A + B * |A on previous block | then B * |A | * +-- end of allocated chunk --+ freelength : C * |B | (incl overflow) * +== end of compressed data ==+ * |C | <-- freerl freecnt : C + D * |C chunk may overflow | * |C on next block | * +-- end of allocated chunk --+ * |D | * |D chunk may overflow | * 15 |D on next block | * +======== end of block ======+ * */ static int ntfs_compress_overwr_free( ntfs_attr *na, runlist_element *rl, s32 usedcnt, s32 freecnt, VCN *update_from ) { BOOL beginhole; BOOL mergeholes; s32 oldlength; s32 freelength; s64 freelcn; s64 freevcn; runlist_element *freerl; ntfs_volume *vol; s32 carry; int res; vol = na->ni->vol; res = 0; freelcn = rl->lcn + usedcnt; freevcn = rl->vcn + usedcnt; freelength = rl->length - usedcnt; beginhole = !usedcnt && !rl->vcn; /* can merge with hole before ? */ mergeholes = !usedcnt && rl[0].vcn && ( rl[-1].lcn == LCN_HOLE ); /* truncate current run, carry to subsequent hole */ carry = freelength; oldlength = rl->length; if ( mergeholes ) { /* merging with a hole before */ freerl = rl; } else { rl->length -= freelength; /* warning : can be zero */ freerl = ++rl; } if ( !mergeholes && ( usedcnt || beginhole ) ) { s32 freed; runlist_element *frl; runlist_element *erl; int holes = 0; BOOL threeparts; /* free the unneeded clusters from initial run, then freerl */ threeparts = ( freelength > freecnt ); freed = 0; frl = freerl; if ( freelength ) { res = ntfs_cluster_free_basic( vol, freelcn, ( threeparts ? freecnt : freelength ) ); if ( !res ) freed += ( threeparts ? freecnt : freelength ); if ( !usedcnt ) { holes++; freerl--; freerl->length += ( threeparts ? freecnt : freelength ); if ( freerl->vcn < *update_from ) *update_from = freerl->vcn; } } while ( !res && frl->length && ( freed < freecnt ) ) { if ( frl->length <= ( freecnt - freed ) ) { res = ntfs_cluster_free_basic( vol, frl->lcn, frl->length ); if ( !res ) { freed += frl->length; frl->lcn = LCN_HOLE; frl->length += carry; carry = 0; holes++; } } else { res = ntfs_cluster_free_basic( vol, frl->lcn, freecnt - freed ); if ( !res ) { frl->lcn += freecnt - freed; frl->vcn += freecnt - freed; frl->length -= freecnt - freed; freed = freecnt; } } frl++; } na->compressed_size -= freed << vol->cluster_size_bits; switch ( holes ) { case 0 : /* there are no hole, must insert one */ /* space for hole has been prereserved */ if ( freerl->lcn == LCN_HOLE ) { if ( threeparts ) { erl = freerl; while ( erl->length ) erl++; do { erl[2] = *erl; } while ( erl-- != freerl ); freerl[1].length = freelength - freecnt; freerl->length = freecnt; freerl[1].lcn = freelcn + freecnt; freerl[1].vcn = freevcn + freecnt; freerl[2].lcn = LCN_HOLE; freerl[2].vcn = freerl[1].vcn + freerl[1].length; freerl->vcn = freevcn; } else { freerl->vcn = freevcn; freerl->length += freelength; } } else { erl = freerl; while ( erl->length ) erl++; if ( threeparts ) { do { erl[2] = *erl; } while ( erl-- != freerl ); freerl[1].lcn = freelcn + freecnt; freerl[1].vcn = freevcn + freecnt; freerl[1].length = oldlength - usedcnt - freecnt; } else { do { erl[1] = *erl; } while ( erl-- != freerl ); } freerl->lcn = LCN_HOLE; freerl->vcn = freevcn; freerl->length = freecnt; } break; case 1 : /* there is a single hole, may have to merge */ freerl->vcn = freevcn; if ( freerl[1].lcn == LCN_HOLE ) { freerl->length += freerl[1].length; erl = freerl; do { erl++; *erl = erl[1]; } while ( erl->length ); } break; default : /* there were several holes, must merge them */ freerl->lcn = LCN_HOLE; freerl->vcn = freevcn; freerl->length = freecnt; if ( freerl[holes].lcn == LCN_HOLE ) { freerl->length += freerl[holes].length; holes++; } erl = freerl; do { erl++; *erl = erl[holes - 1]; } while ( erl->length ); break; } } else { s32 freed; runlist_element *frl; runlist_element *xrl; freed = 0; frl = freerl--; if ( freerl->vcn < *update_from ) *update_from = freerl->vcn; while ( !res && frl->length && ( freed < freecnt ) ) { if ( frl->length <= ( freecnt - freed ) ) { freerl->length += frl->length; freed += frl->length; res = ntfs_cluster_free_basic( vol, frl->lcn, frl->length ); frl++; } else { freerl->length += freecnt - freed; res = ntfs_cluster_free_basic( vol, frl->lcn, freecnt - freed ); frl->lcn += freecnt - freed; frl->vcn += freecnt - freed; frl->length -= freecnt - freed; freed = freecnt; } } /* remove unneded runlist entries */ xrl = freerl; /* group with next run if also a hole */ if ( frl->length && ( frl->lcn == LCN_HOLE ) ) { xrl->length += frl->length; frl++; } while ( frl->length ) { *++xrl = *frl++; } *++xrl = *frl; /* terminator */ na->compressed_size -= freed << vol->cluster_size_bits; } return ( res ); } /* * Free unneeded clusters after compression * * This generally requires one or two empty slots at the end of runlist, * but we do not want to reallocate the runlist here because * there are many pointers to it. * So the empty slots have to be reserved beforehand * * Returns zero unless some error occurred (described by errno) */ static int ntfs_compress_free( ntfs_attr *na, runlist_element *rl, s64 used, s64 reserved, BOOL appending, VCN *update_from ) { s32 freecnt; s32 usedcnt; int res; s64 freelcn; s64 freevcn; s32 freelength; BOOL mergeholes; BOOL beginhole; ntfs_volume *vol; runlist_element *freerl; res = -1; /* default return */ vol = na->ni->vol; freecnt = ( reserved - used ) >> vol->cluster_size_bits; usedcnt = ( reserved >> vol->cluster_size_bits ) - freecnt; if ( rl->vcn < *update_from ) *update_from = rl->vcn; /* skip entries fully used, if any */ while ( rl->length && ( rl->length < usedcnt ) ) { usedcnt -= rl->length; /* must be > 0 */ rl++; } if ( rl->length ) { /* * Splitting the current allocation block requires * an extra runlist element to create the hole. * The required entry has been prereserved when * mapping the runlist. */ /* get the free part in initial run */ freelcn = rl->lcn + usedcnt; freevcn = rl->vcn + usedcnt; /* new count of allocated clusters */ if ( !( ( freevcn + freecnt ) & ( na->compression_block_clusters - 1 ) ) ) { if ( !appending ) res = ntfs_compress_overwr_free( na, rl, usedcnt, freecnt, update_from ); else { freelength = rl->length - usedcnt; beginhole = !usedcnt && !rl->vcn; mergeholes = !usedcnt && rl[0].vcn && ( rl[-1].lcn == LCN_HOLE ); if ( mergeholes ) { s32 carry; /* shorten the runs which have free space */ carry = freecnt; freerl = rl; while ( freerl->length < carry ) { carry -= freerl->length; freerl++; } freerl->length = carry; freerl = rl; } else { rl->length = usedcnt; /* can be zero ? */ freerl = ++rl; } if ( ( freelength > 0 ) && !mergeholes && ( usedcnt || beginhole ) ) { /* * move the unused part to the end. Doing so, * the vcn will be out of order. This does * not harm, the vcn are meaningless now, and * only the lcn are meaningful for freeing. */ /* locate current end */ while ( rl->length ) rl++; /* new terminator relocated */ rl[1].vcn = rl->vcn; rl[1].lcn = LCN_ENOENT; rl[1].length = 0; /* hole, currently allocated */ rl->vcn = freevcn; rl->lcn = freelcn; rl->length = freelength; } else { /* why is this different from the begin hole case ? */ if ( ( freelength > 0 ) && !mergeholes && !usedcnt ) { freerl--; freerl->length = freelength; if ( freerl->vcn < *update_from ) *update_from = freerl->vcn; } } /* free the hole */ res = ntfs_cluster_free_from_rl( vol, freerl ); if ( !res ) { na->compressed_size -= freecnt << vol->cluster_size_bits; if ( mergeholes ) { /* merge with adjacent hole */ freerl--; freerl->length += freecnt; } else { if ( beginhole ) freerl--; /* mark hole as free */ freerl->lcn = LCN_HOLE; freerl->vcn = freevcn; freerl->length = freecnt; } if ( freerl->vcn < *update_from ) *update_from = freerl->vcn; /* and set up the new end */ freerl[1].lcn = LCN_ENOENT; freerl[1].vcn = freevcn + freecnt; freerl[1].length = 0; } } } else { ntfs_log_error( "Bad end of a compression block set\n" ); errno = EIO; } } else { ntfs_log_error( "No cluster to free after compression\n" ); errno = EIO; } return ( res ); } /* * Read existing data, decompress and append buffer * Do nothing if something fails */ static int ntfs_read_append( ntfs_attr *na, const runlist_element *rl, s64 offs, u32 compsz, s32 pos, BOOL appending, char *outbuf, s64 to_write, const void *b ) { int fail = 1; char *compbuf; u32 decompsz; u32 got; if ( compsz == na->compression_block_size ) { /* if the full block was requested, it was a hole */ memset( outbuf, 0, compsz ); memcpy( &outbuf[pos], b, to_write ); fail = 0; } else { compbuf = ( char* )ntfs_malloc( compsz ); if ( compbuf ) { /* must align to full block for decompression */ if ( appending ) decompsz = ( ( pos - 1 ) | ( NTFS_SB_SIZE - 1 ) ) + 1; else decompsz = na->compression_block_size; got = read_clusters( na->ni->vol, rl, offs, compsz, compbuf ); if ( ( got == compsz ) && !ntfs_decompress( ( u8* )outbuf, decompsz, ( u8* )compbuf, compsz ) ) { memcpy( &outbuf[pos], b, to_write ); fail = 0; } free( compbuf ); } } return ( fail ); } /* * Flush a full compression block * * returns the size actually written (rounded to a full cluster) * or 0 if could not compress (and written uncompressed) * or -1 if there were an irrecoverable error (errno set) */ static int ntfs_flush( ntfs_attr *na, runlist_element *rl, s64 offs, const char *outbuf, s32 count, BOOL compress, BOOL appending, VCN *update_from ) { int rounded; int written; int clsz; if ( compress ) { written = ntfs_comp_set( na, rl, offs, count, outbuf ); if ( written == -1 ) compress = FALSE; if ( ( written >= 0 ) && ntfs_compress_free( na, rl, offs + written, offs + na->compression_block_size, appending, update_from ) ) written = -1; } else written = 0; if ( !compress ) { clsz = 1 << na->ni->vol->cluster_size_bits; rounded = ( ( count - 1 ) | ( clsz - 1 ) ) + 1; written = write_clusters( na->ni->vol, rl, offs, rounded, outbuf ); if ( written != rounded ) written = -1; } return ( written ); } /* * Write some data to be compressed. * Compression only occurs when a few clusters (usually 16) are * full. When this occurs an extra runlist slot may be needed, so * it has to be reserved beforehand. * * Returns the size of uncompressed data written, * or negative if an error occurred. * When the returned size is less than requested, new clusters have * to be allocated before the function is called again. */ s64 ntfs_compressed_pwrite( ntfs_attr *na, runlist_element *wrl, s64 wpos, s64 offs, s64 to_write, s64 rounded, const void *b, int compressed_part, VCN *update_from ) { ntfs_volume *vol; runlist_element *brl; /* entry containing the beginning of block */ int compression_length; s64 written; s64 to_read; s64 to_flush; s64 roffs; s64 got; s64 start_vcn; s64 nextblock; s64 endwrite; u32 compsz; char *inbuf; char *outbuf; BOOL fail; BOOL done; BOOL compress; BOOL appending; if ( !valid_compressed_run( na, wrl, FALSE, "begin compressed write" ) ) { return ( -1 ); } if ( ( *update_from < 0 ) || ( compressed_part < 0 ) || ( compressed_part > ( int )na->compression_block_clusters ) ) { ntfs_log_error( "Bad update vcn or compressed_part %d for compressed write\n", compressed_part ); errno = EIO; return ( -1 ); } /* make sure there are two unused entries in runlist */ if ( na->unused_runs < 2 ) { ntfs_log_error( "No unused runs for compressed write\n" ); errno = EIO; return ( -1 ); } if ( wrl->vcn < *update_from ) *update_from = wrl->vcn; written = -1; /* default return */ vol = na->ni->vol; compression_length = na->compression_block_clusters; compress = FALSE; done = FALSE; /* * Cannot accept writing beyond the current compression set * because when compression occurs, clusters are freed * and have to be reallocated. * (cannot happen with standard fuse 4K buffers) * Caller has to avoid this situation, or face consequences. */ nextblock = ( ( offs + ( wrl->vcn << vol->cluster_size_bits ) ) | ( na->compression_block_size - 1 ) ) + 1; /* determine whether we are appending to file */ endwrite = offs + to_write + ( wrl->vcn << vol->cluster_size_bits ); appending = endwrite >= na->initialized_size; if ( endwrite >= nextblock ) { /* it is time to compress */ compress = TRUE; /* only process what we can */ to_write = rounded = nextblock - ( offs + ( wrl->vcn << vol->cluster_size_bits ) ); } start_vcn = 0; fail = FALSE; brl = wrl; roffs = 0; /* * If we are about to compress or we need to decompress * existing data, we have to process a full set of blocks. * So relocate the parameters to the beginning of allocation * containing the first byte of the set of blocks. */ if ( compress || compressed_part ) { /* find the beginning of block */ start_vcn = ( wrl->vcn + ( offs >> vol->cluster_size_bits ) ) & -compression_length; if ( start_vcn < *update_from ) *update_from = start_vcn; while ( brl->vcn && ( brl->vcn > start_vcn ) ) { /* jumping back a hole means big trouble */ if ( brl->lcn == ( LCN )LCN_HOLE ) { ntfs_log_error( "jump back over a hole when appending\n" ); fail = TRUE; errno = EIO; } brl--; offs += brl->length << vol->cluster_size_bits; } roffs = ( start_vcn - brl->vcn ) << vol->cluster_size_bits; } if ( compressed_part && !fail ) { /* * The set of compression blocks contains compressed data * (we are reopening an existing file to append to it) * Decompress the data and append */ compsz = compressed_part << vol->cluster_size_bits; outbuf = ( char* )ntfs_malloc( na->compression_block_size ); if ( outbuf ) { if ( appending ) { to_read = offs - roffs; to_flush = to_read + to_write; } else { to_read = na->data_size - ( brl->vcn << vol->cluster_size_bits ); if ( to_read > na->compression_block_size ) to_read = na->compression_block_size; to_flush = to_read; } if ( !ntfs_read_append( na, brl, roffs, compsz, ( s32 )( offs - roffs ), appending, outbuf, to_write, b ) ) { written = ntfs_flush( na, brl, roffs, outbuf, to_flush, compress, appending, update_from ); if ( written >= 0 ) { written = to_write; done = TRUE; } } free( outbuf ); } } else { if ( compress && !fail ) { /* * we are filling up a block, read the full set * of blocks and compress it */ inbuf = ( char* )ntfs_malloc( na->compression_block_size ); if ( inbuf ) { to_read = offs - roffs; if ( to_read ) got = read_clusters( vol, brl, roffs, to_read, inbuf ); else got = 0; if ( got == to_read ) { memcpy( &inbuf[to_read], b, to_write ); written = ntfs_comp_set( na, brl, roffs, to_read + to_write, inbuf ); /* * if compression was not successful, * only write the part which was requested */ if ( ( written >= 0 ) /* free the unused clusters */ && !ntfs_compress_free( na, brl, written + roffs, na->compression_block_size + roffs, appending, update_from ) ) { done = TRUE; written = to_write; } } free( inbuf ); } } if ( !done ) { /* * if the compression block is not full, or * if compression failed for whatever reason, * write uncompressed */ /* check we are not overflowing current allocation */ if ( ( wpos + rounded ) > ( ( wrl->lcn + wrl->length ) << vol->cluster_size_bits ) ) { ntfs_log_error( "writing on unallocated clusters\n" ); errno = EIO; } else { written = ntfs_pwrite( vol->dev, wpos, rounded, b ); if ( written == rounded ) written = to_write; } } } if ( ( written >= 0 ) && !valid_compressed_run( na, wrl, TRUE, "end compressed write" ) ) written = -1; return ( written ); } /* * Close a file written compressed. * This compresses the last partial compression block of the file. * Two empty runlist slots have to be reserved beforehand. * * Returns zero if closing is successful. */ int ntfs_compressed_close( ntfs_attr *na, runlist_element *wrl, s64 offs, VCN *update_from ) { ntfs_volume *vol; runlist_element *brl; /* entry containing the beginning of block */ int compression_length; s64 written; s64 to_read; s64 roffs; s64 got; s64 start_vcn; char *inbuf; BOOL fail; BOOL done; if ( na->unused_runs < 2 ) { ntfs_log_error( "No unused runs for compressed close\n" ); errno = EIO; return ( -1 ); } if ( *update_from < 0 ) { ntfs_log_error( "Bad update vcn for compressed close\n" ); errno = EIO; return ( -1 ); } if ( wrl->vcn < *update_from ) *update_from = wrl->vcn; vol = na->ni->vol; compression_length = na->compression_block_clusters; done = FALSE; /* * There generally is an uncompressed block at end of file, * read the full block and compress it */ inbuf = ( char* )ntfs_malloc( na->compression_block_size ); if ( inbuf ) { start_vcn = ( wrl->vcn + ( offs >> vol->cluster_size_bits ) ) & -compression_length; if ( start_vcn < *update_from ) *update_from = start_vcn; to_read = offs + ( ( wrl->vcn - start_vcn ) << vol->cluster_size_bits ); brl = wrl; fail = FALSE; while ( brl->vcn && ( brl->vcn > start_vcn ) ) { if ( brl->lcn == ( LCN )LCN_HOLE ) { ntfs_log_error( "jump back over a hole when closing\n" ); fail = TRUE; errno = EIO; } brl--; } if ( !fail ) { /* roffs can be an offset from another uncomp block */ roffs = ( start_vcn - brl->vcn ) << vol->cluster_size_bits; if ( to_read ) { got = read_clusters( vol, brl, roffs, to_read, inbuf ); if ( got == to_read ) { written = ntfs_comp_set( na, brl, roffs, to_read, inbuf ); if ( ( written >= 0 ) /* free the unused clusters */ && !ntfs_compress_free( na, brl, written + roffs, na->compression_block_size + roffs, TRUE, update_from ) ) { done = TRUE; } else /* if compression failed, leave uncompressed */ if ( written == -1 ) done = TRUE; } } else done = TRUE; free( inbuf ); } } if ( done && !valid_compressed_run( na, wrl, TRUE, "end compressed close" ) ) done = FALSE; return ( !done ); }