fs/ntfs/mst.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * mst.c - NTFS multi sector transfer protection handling code. Part of the
   4  *         Linux-NTFS project.
   5  *
   6  * Copyright (c) 2001-2004 Anton Altaparmakov
   7  */
   8
   9 #include "ntfs.h"
  10
  11 /**
  12  * post_read_mst_fixup - deprotect multi sector transfer protected data
  13  * @b:          pointer to the data to deprotect
  14  * @size:       size in bytes of @b
  15  *
  16  * Perform the necessary post read multi sector transfer fixup and detect the
  17  * presence of incomplete multi sector transfers. - In that case, overwrite the
  18  * magic of the ntfs record header being processed with "BAAD" (in memory only!)
  19  * and abort processing.
  20  *
  21  * Return 0 on success and -EINVAL on error ("BAAD" magic will be present).
  22  *
  23  * NOTE: We consider the absence / invalidity of an update sequence array to
  24  * mean that the structure is not protected at all and hence doesn't need to
  25  * be fixed up. Thus, we return success and not failure in this case. This is
  26  * in contrast to pre_write_mst_fixup(), see below.
  27  */
  28 int post_read_mst_fixup(NTFS_RECORD *b, const u32 size)
  29 {
  30         u16 usa_ofs, usa_count, usn;
  31         u16 *usa_pos, *data_pos;
  32
  33         /* Setup the variables. */
  34         usa_ofs = le16_to_cpu(b->usa_ofs);
  35         /* Decrement usa_count to get number of fixups. */
  36         usa_count = le16_to_cpu(b->usa_count) - 1;
  37         /* Size and alignment checks. */
  38         if ( size & (NTFS_BLOCK_SIZE - 1)       ||
  39              usa_ofs & 1                        ||
  40              usa_ofs + (usa_count * 2) > size   ||
  41              (size >> NTFS_BLOCK_SIZE_BITS) != usa_count)
  42                 return 0;
  43         /* Position of usn in update sequence array. */
  44         usa_pos = (u16*)b + usa_ofs/sizeof(u16);
  45         /*
  46          * The update sequence number which has to be equal to each of the
  47          * u16 values before they are fixed up. Note no need to care for
  48          * endianness since we are comparing and moving data for on disk
  49          * structures which means the data is consistent. - If it is
  50          * consistenty the wrong endianness it doesn't make any difference.
  51          */
  52         usn = *usa_pos;
  53         /*
  54          * Position in protected data of first u16 that needs fixing up.
  55          */
  56         data_pos = (u16*)b + NTFS_BLOCK_SIZE/sizeof(u16) - 1;
  57         /*
  58          * Check for incomplete multi sector transfer(s).
  59          */
  60         while (usa_count--) {
  61                 if (*data_pos != usn) {
  62                         /*
  63                          * Incomplete multi sector transfer detected! )-:
  64                          * Set the magic to "BAAD" and return failure.
  65                          * Note that magic_BAAD is already converted to le32.
  66                          */
  67                         b->magic = magic_BAAD;
  68                         return -EINVAL;
  69                 }
  70                 data_pos += NTFS_BLOCK_SIZE/sizeof(u16);
  71         }
  72         /* Re-setup the variables. */
  73         usa_count = le16_to_cpu(b->usa_count) - 1;
  74         data_pos = (u16*)b + NTFS_BLOCK_SIZE/sizeof(u16) - 1;
  75         /* Fixup all sectors. */
  76         while (usa_count--) {
  77                 /*
  78                  * Increment position in usa and restore original data from
  79                  * the usa into the data buffer.
  80                  */
  81                 *data_pos = *(++usa_pos);
  82                 /* Increment position in data as well. */
  83                 data_pos += NTFS_BLOCK_SIZE/sizeof(u16);
  84         }
  85         return 0;
  86 }
  87
  88 /**
  89  * pre_write_mst_fixup - apply multi sector transfer protection
  90  * @b:          pointer to the data to protect
  91  * @size:       size in bytes of @b
  92  *
  93  * Perform the necessary pre write multi sector transfer fixup on the data
  94  * pointer to by @b of @size.
  95  *
  96  * Return 0 if fixup applied (success) or -EINVAL if no fixup was performed
  97  * (assumed not needed). This is in contrast to post_read_mst_fixup() above.
  98  *
  99  * NOTE: We consider the absence / invalidity of an update sequence array to
 100  * mean that the structure is not subject to protection and hence doesn't need
 101  * to be fixed up. This means that you have to create a valid update sequence
 102  * array header in the ntfs record before calling this function, otherwise it
 103  * will fail (the header needs to contain the position of the update sequence
 104  * array together with the number of elements in the array). You also need to
 105  * initialise the update sequence number before calling this function
 106  * otherwise a random word will be used (whatever was in the record at that
 107  * position at that time).
 108  */
 109 int pre_write_mst_fixup(NTFS_RECORD *b, const u32 size)
 110 {
 111         le16 *usa_pos, *data_pos;
 112         u16 usa_ofs, usa_count, usn;
 113         le16 le_usn;
 114
 115         /* Sanity check + only fixup if it makes sense. */
 116         if (!b || ntfs_is_baad_record(b->magic) ||
 117                         ntfs_is_hole_record(b->magic))
 118                 return -EINVAL;
 119         /* Setup the variables. */
 120         usa_ofs = le16_to_cpu(b->usa_ofs);
 121         /* Decrement usa_count to get number of fixups. */
 122         usa_count = le16_to_cpu(b->usa_count) - 1;
 123         /* Size and alignment checks. */
 124         if ( size & (NTFS_BLOCK_SIZE - 1)       ||
 125              usa_ofs & 1                        ||
 126              usa_ofs + (usa_count * 2) > size   ||
 127              (size >> NTFS_BLOCK_SIZE_BITS) != usa_count)
 128                 return -EINVAL;
 129         /* Position of usn in update sequence array. */
 130         usa_pos = (le16*)((u8*)b + usa_ofs);
 131         /*
 132          * Cyclically increment the update sequence number
 133          * (skipping 0 and -1, i.e. 0xffff).
 134          */
 135         usn = le16_to_cpup(usa_pos) + 1;
 136         if (usn == 0xffff || !usn)
 137                 usn = 1;
 138         le_usn = cpu_to_le16(usn);
 139         *usa_pos = le_usn;
 140         /* Position in data of first u16 that needs fixing up. */
 141         data_pos = (le16*)b + NTFS_BLOCK_SIZE/sizeof(le16) - 1;
 142         /* Fixup all sectors. */
 143         while (usa_count--) {
 144                 /*
 145                  * Increment the position in the usa and save the
 146                  * original data from the data buffer into the usa.
 147                  */
 148                 *(++usa_pos) = *data_pos;
 149                 /* Apply fixup to data. */
 150                 *data_pos = le_usn;
 151                 /* Increment position in data as well. */
 152                 data_pos += NTFS_BLOCK_SIZE/sizeof(le16);
 153         }
 154         return 0;
 155 }
 156
 157 /**
 158  * post_write_mst_fixup - fast deprotect multi sector transfer protected data
 159  * @b:          pointer to the data to deprotect
 160  *
 161  * Perform the necessary post write multi sector transfer fixup, not checking
 162  * for any errors, because we assume we have just used pre_write_mst_fixup(),
 163  * thus the data will be fine or we would never have gotten here.
 164  */
 165 void post_write_mst_fixup(NTFS_RECORD *b)
 166 {
 167         le16 *usa_pos, *data_pos;
 168
 169         u16 usa_ofs = le16_to_cpu(b->usa_ofs);
 170         u16 usa_count = le16_to_cpu(b->usa_count) - 1;
 171
 172         /* Position of usn in update sequence array. */
 173         usa_pos = (le16*)b + usa_ofs/sizeof(le16);
 174
 175         /* Position in protected data of first u16 that needs fixing up. */
 176         data_pos = (le16*)b + NTFS_BLOCK_SIZE/sizeof(le16) - 1;
 177
 178         /* Fixup all sectors. */
 179         while (usa_count--) {
 180                 /*
 181                  * Increment position in usa and restore original data from
 182                  * the usa into the data buffer.
 183                  */
 184                 *data_pos = *(++usa_pos);
 185
 186                 /* Increment position in data as well. */
 187                 data_pos += NTFS_BLOCK_SIZE/sizeof(le16);
 188         }
 189 }