| 1 |
1275 |
phoenix |
/*
|
| 2 |
|
|
* inode.c
|
| 3 |
|
|
*
|
| 4 |
|
|
* Copyright (C) 1995-1999 Martin von Löwis
|
| 5 |
|
|
* Copyright (C) 1996 Albert D. Cahalan
|
| 6 |
|
|
* Copyright (C) 1996-1997 Régis Duchesne
|
| 7 |
|
|
* Copyright (C) 1998 Joseph Malicki
|
| 8 |
|
|
* Copyright (C) 1999 Steve Dodd
|
| 9 |
|
|
* Copyright (C) 2000-2001 Anton Altaparmakov (AIA)
|
| 10 |
|
|
*/
|
| 11 |
|
|
#include "ntfstypes.h"
|
| 12 |
|
|
#include "ntfsendian.h"
|
| 13 |
|
|
#include "struct.h"
|
| 14 |
|
|
#include "inode.h"
|
| 15 |
|
|
#include <linux/errno.h>
|
| 16 |
|
|
#include "macros.h"
|
| 17 |
|
|
#include "attr.h"
|
| 18 |
|
|
#include "super.h"
|
| 19 |
|
|
#include "dir.h"
|
| 20 |
|
|
#include "support.h"
|
| 21 |
|
|
#include "util.h"
|
| 22 |
|
|
#include <linux/ntfs_fs.h>
|
| 23 |
|
|
#include <linux/smp_lock.h>
|
| 24 |
|
|
|
| 25 |
|
|
typedef struct {
|
| 26 |
|
|
int recno;
|
| 27 |
|
|
unsigned char *record;
|
| 28 |
|
|
} ntfs_mft_record;
|
| 29 |
|
|
|
| 30 |
|
|
typedef struct {
|
| 31 |
|
|
int size;
|
| 32 |
|
|
int count;
|
| 33 |
|
|
ntfs_mft_record *records;
|
| 34 |
|
|
} ntfs_disk_inode;
|
| 35 |
|
|
|
| 36 |
|
|
static void ntfs_fill_mft_header(ntfs_u8 *mft, int rec_size, int seq_no,
|
| 37 |
|
|
int links, int flags)
|
| 38 |
|
|
{
|
| 39 |
|
|
int fixup_ofs = 0x2a;
|
| 40 |
|
|
int fixup_cnt = rec_size / NTFS_SECTOR_SIZE + 1;
|
| 41 |
|
|
int attr_ofs = (fixup_ofs + 2 * fixup_cnt + 7) & ~7;
|
| 42 |
|
|
|
| 43 |
|
|
NTFS_PUTU32(mft + 0x00, 0x454c4946); /* FILE */
|
| 44 |
|
|
NTFS_PUTU16(mft + 0x04, fixup_ofs); /* Offset to fixup. */
|
| 45 |
|
|
NTFS_PUTU16(mft + 0x06, fixup_cnt); /* Number of fixups. */
|
| 46 |
|
|
NTFS_PUTU64(mft + 0x08, 0); /* Logical sequence number. */
|
| 47 |
|
|
NTFS_PUTU16(mft + 0x10, seq_no); /* Sequence number. */
|
| 48 |
|
|
NTFS_PUTU16(mft + 0x12, links); /* Hard link count. */
|
| 49 |
|
|
NTFS_PUTU16(mft + 0x14, attr_ofs); /* Offset to attributes. */
|
| 50 |
|
|
NTFS_PUTU16(mft + 0x16, flags); /* Flags: 1 = In use,
|
| 51 |
|
|
2 = Directory. */
|
| 52 |
|
|
NTFS_PUTU32(mft + 0x18, attr_ofs + 8); /* Bytes in use. */
|
| 53 |
|
|
NTFS_PUTU32(mft + 0x1c, rec_size); /* Total allocated size. */
|
| 54 |
|
|
NTFS_PUTU64(mft + 0x20, 0); /* Base mft record. */
|
| 55 |
|
|
NTFS_PUTU16(mft + 0x28, 0); /* Next attr instance. */
|
| 56 |
|
|
NTFS_PUTU16(mft + fixup_ofs, 1); /* Fixup word. */
|
| 57 |
|
|
NTFS_PUTU32(mft + attr_ofs, (__u32)-1); /* End of attributes marker. */
|
| 58 |
|
|
}
|
| 59 |
|
|
|
| 60 |
|
|
/*
|
| 61 |
|
|
* Search in an inode an attribute by type and name.
|
| 62 |
|
|
* FIXME: Check that when attributes are inserted all attribute list
|
| 63 |
|
|
* attributes are expanded otherwise need to modify this function to deal
|
| 64 |
|
|
* with attribute lists. (AIA)
|
| 65 |
|
|
*/
|
| 66 |
|
|
ntfs_attribute *ntfs_find_attr(ntfs_inode *ino, int type, char *name)
|
| 67 |
|
|
{
|
| 68 |
|
|
int i;
|
| 69 |
|
|
|
| 70 |
|
|
if (!ino) {
|
| 71 |
|
|
ntfs_error("ntfs_find_attr: NO INODE!\n");
|
| 72 |
|
|
return 0;
|
| 73 |
|
|
}
|
| 74 |
|
|
for (i = 0; i < ino->attr_count; i++) {
|
| 75 |
|
|
if (type < ino->attrs[i].type)
|
| 76 |
|
|
return 0;
|
| 77 |
|
|
if (type == ino->attrs[i].type) {
|
| 78 |
|
|
if (!name) {
|
| 79 |
|
|
if (!ino->attrs[i].name)
|
| 80 |
|
|
return ino->attrs + i;
|
| 81 |
|
|
} else if (ino->attrs[i].name &&
|
| 82 |
|
|
!ntfs_ua_strncmp(ino->attrs[i].name, name,
|
| 83 |
|
|
strlen(name)))
|
| 84 |
|
|
return ino->attrs + i;
|
| 85 |
|
|
}
|
| 86 |
|
|
}
|
| 87 |
|
|
return 0;
|
| 88 |
|
|
}
|
| 89 |
|
|
|
| 90 |
|
|
/*
|
| 91 |
|
|
* Insert all attributes from the record mftno of the MFT in the inode ino.
|
| 92 |
|
|
* If mftno is a base mft record we abort as soon as we find the attribute
|
| 93 |
|
|
* list, but only on the first pass. We will get called later when the attribute
|
| 94 |
|
|
* list attribute is being parsed so we need to distinguish the two cases.
|
| 95 |
|
|
* FIXME: We should be performing structural consistency checks. (AIA)
|
| 96 |
|
|
* Return 0 on success or -errno on error.
|
| 97 |
|
|
*/
|
| 98 |
|
|
static int ntfs_insert_mft_attributes(ntfs_inode* ino, char *mft, int mftno)
|
| 99 |
|
|
{
|
| 100 |
|
|
int i, error, type, len, present = 0;
|
| 101 |
|
|
char *it;
|
| 102 |
|
|
|
| 103 |
|
|
/* Check for duplicate extension record. */
|
| 104 |
|
|
for(i = 0; i < ino->record_count; i++)
|
| 105 |
|
|
if (ino->records[i] == mftno) {
|
| 106 |
|
|
if (i)
|
| 107 |
|
|
return 0;
|
| 108 |
|
|
present = 1;
|
| 109 |
|
|
break;
|
| 110 |
|
|
}
|
| 111 |
|
|
if (!present) {
|
| 112 |
|
|
/* (re-)allocate space if necessary. */
|
| 113 |
|
|
if (ino->record_count % 8 == 0) {
|
| 114 |
|
|
int *new;
|
| 115 |
|
|
|
| 116 |
|
|
new = ntfs_malloc((ino->record_count + 8) *
|
| 117 |
|
|
sizeof(int));
|
| 118 |
|
|
if (!new)
|
| 119 |
|
|
return -ENOMEM;
|
| 120 |
|
|
if (ino->records) {
|
| 121 |
|
|
for (i = 0; i < ino->record_count; i++)
|
| 122 |
|
|
new[i] = ino->records[i];
|
| 123 |
|
|
ntfs_free(ino->records);
|
| 124 |
|
|
}
|
| 125 |
|
|
ino->records = new;
|
| 126 |
|
|
}
|
| 127 |
|
|
ino->records[ino->record_count] = mftno;
|
| 128 |
|
|
ino->record_count++;
|
| 129 |
|
|
}
|
| 130 |
|
|
it = mft + NTFS_GETU16(mft + 0x14); /* mft->attrs_offset */
|
| 131 |
|
|
do {
|
| 132 |
|
|
type = NTFS_GETU32(it);
|
| 133 |
|
|
len = NTFS_GETU32(it + 4);
|
| 134 |
|
|
if (type != -1) {
|
| 135 |
|
|
error = ntfs_insert_attribute(ino, it);
|
| 136 |
|
|
if (error)
|
| 137 |
|
|
return error;
|
| 138 |
|
|
}
|
| 139 |
|
|
/* If we have just processed the attribute list and this is
|
| 140 |
|
|
* the first time we are parsing this (base) mft record then we
|
| 141 |
|
|
* are done so that the attribute list gets parsed before the
|
| 142 |
|
|
* entries in the base mft record. Otherwise we run into
|
| 143 |
|
|
* problems with encountering attributes out of order and when
|
| 144 |
|
|
* this happens with different attribute extents we die. )-:
|
| 145 |
|
|
* This way we are ok as the attribute list is always sorted
|
| 146 |
|
|
* fully and correctly. (-: */
|
| 147 |
|
|
if (type == 0x20 && !present)
|
| 148 |
|
|
return 0;
|
| 149 |
|
|
it += len;
|
| 150 |
|
|
} while (type != -1); /* Attribute listing ends with type -1. */
|
| 151 |
|
|
return 0;
|
| 152 |
|
|
}
|
| 153 |
|
|
|
| 154 |
|
|
/*
|
| 155 |
|
|
* Insert a single specific attribute from the record mftno of the MFT in the
|
| 156 |
|
|
* inode ino. We disregard the attribute list assuming we have already parsed
|
| 157 |
|
|
* it.
|
| 158 |
|
|
* FIXME: We should be performing structural consistency checks. (AIA)
|
| 159 |
|
|
* Return 0 on success or -errno on error.
|
| 160 |
|
|
*/
|
| 161 |
|
|
static int ntfs_insert_mft_attribute(ntfs_inode* ino, int mftno,
|
| 162 |
|
|
ntfs_u8 *attr)
|
| 163 |
|
|
{
|
| 164 |
|
|
int i, error, present = 0;
|
| 165 |
|
|
|
| 166 |
|
|
/* Check for duplicate extension record. */
|
| 167 |
|
|
for(i = 0; i < ino->record_count; i++)
|
| 168 |
|
|
if (ino->records[i] == mftno) {
|
| 169 |
|
|
present = 1;
|
| 170 |
|
|
break;
|
| 171 |
|
|
}
|
| 172 |
|
|
if (!present) {
|
| 173 |
|
|
/* (re-)allocate space if necessary. */
|
| 174 |
|
|
if (ino->record_count % 8 == 0) {
|
| 175 |
|
|
int *new;
|
| 176 |
|
|
|
| 177 |
|
|
new = ntfs_malloc((ino->record_count + 8) *
|
| 178 |
|
|
sizeof(int));
|
| 179 |
|
|
if (!new)
|
| 180 |
|
|
return -ENOMEM;
|
| 181 |
|
|
if (ino->records) {
|
| 182 |
|
|
for (i = 0; i < ino->record_count; i++)
|
| 183 |
|
|
new[i] = ino->records[i];
|
| 184 |
|
|
ntfs_free(ino->records);
|
| 185 |
|
|
}
|
| 186 |
|
|
ino->records = new;
|
| 187 |
|
|
}
|
| 188 |
|
|
ino->records[ino->record_count] = mftno;
|
| 189 |
|
|
ino->record_count++;
|
| 190 |
|
|
}
|
| 191 |
|
|
if (NTFS_GETU32(attr) == -1) {
|
| 192 |
|
|
ntfs_debug(DEBUG_FILE3, "ntfs_insert_mft_attribute: attribute "
|
| 193 |
|
|
"type is -1.\n");
|
| 194 |
|
|
return 0;
|
| 195 |
|
|
}
|
| 196 |
|
|
error = ntfs_insert_attribute(ino, attr);
|
| 197 |
|
|
if (error)
|
| 198 |
|
|
return error;
|
| 199 |
|
|
return 0;
|
| 200 |
|
|
}
|
| 201 |
|
|
|
| 202 |
|
|
/* Read and insert all the attributes of an 'attribute list' attribute.
|
| 203 |
|
|
* Return the number of remaining bytes in *plen. */
|
| 204 |
|
|
static int parse_attributes(ntfs_inode *ino, ntfs_u8 *alist, int *plen)
|
| 205 |
|
|
{
|
| 206 |
|
|
ntfs_u8 *mft, *attr;
|
| 207 |
|
|
int mftno, l, error;
|
| 208 |
|
|
int last_mft = -1;
|
| 209 |
|
|
int len = *plen;
|
| 210 |
|
|
int tries = 0;
|
| 211 |
|
|
|
| 212 |
|
|
if (!ino->attr) {
|
| 213 |
|
|
ntfs_error("parse_attributes: called on inode 0x%x without a "
|
| 214 |
|
|
"loaded base mft record.\n", ino->i_number);
|
| 215 |
|
|
return -EINVAL;
|
| 216 |
|
|
}
|
| 217 |
|
|
mft = ntfs_malloc(ino->vol->mft_record_size);
|
| 218 |
|
|
if (!mft)
|
| 219 |
|
|
return -ENOMEM;
|
| 220 |
|
|
while (len > 8) {
|
| 221 |
|
|
l = NTFS_GETU16(alist + 4);
|
| 222 |
|
|
if (l > len)
|
| 223 |
|
|
break;
|
| 224 |
|
|
/* Process an attribute description. */
|
| 225 |
|
|
mftno = NTFS_GETU32(alist + 0x10);
|
| 226 |
|
|
/* FIXME: The mft reference (alist + 0x10) is __s64.
|
| 227 |
|
|
* - Not a problem unless we encounter a huge partition.
|
| 228 |
|
|
* - Should be consistency checking the sequence numbers
|
| 229 |
|
|
* though! This should maybe happen in
|
| 230 |
|
|
* ntfs_read_mft_record() itself and a hotfix could
|
| 231 |
|
|
* then occur there or the user notified to run
|
| 232 |
|
|
* ntfsck. (AIA) */
|
| 233 |
|
|
if (mftno != ino->i_number && mftno != last_mft) {
|
| 234 |
|
|
continue_after_loading_mft_data:
|
| 235 |
|
|
last_mft = mftno;
|
| 236 |
|
|
error = ntfs_read_mft_record(ino->vol, mftno, mft);
|
| 237 |
|
|
if (error) {
|
| 238 |
|
|
if (error == -EINVAL && !tries)
|
| 239 |
|
|
goto force_load_mft_data;
|
| 240 |
|
|
failed_reading_mft_data:
|
| 241 |
|
|
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
|
| 242 |
|
|
"ntfs_read_mft_record(mftno = 0x%x) "
|
| 243 |
|
|
"failed\n", mftno);
|
| 244 |
|
|
ntfs_free(mft);
|
| 245 |
|
|
return error;
|
| 246 |
|
|
}
|
| 247 |
|
|
}
|
| 248 |
|
|
attr = ntfs_find_attr_in_mft_rec(
|
| 249 |
|
|
ino->vol, /* ntfs volume */
|
| 250 |
|
|
mftno == ino->i_number ?/* mft record is: */
|
| 251 |
|
|
ino->attr: /* base record */
|
| 252 |
|
|
mft, /* extension record */
|
| 253 |
|
|
NTFS_GETU32(alist + 0), /* type */
|
| 254 |
|
|
(wchar_t*)(alist + alist[7]), /* name */
|
| 255 |
|
|
alist[6], /* name length */
|
| 256 |
|
|
1, /* ignore case */
|
| 257 |
|
|
NTFS_GETU16(alist + 24) /* instance number */
|
| 258 |
|
|
);
|
| 259 |
|
|
if (!attr) {
|
| 260 |
|
|
ntfs_error("parse_attributes: mft records 0x%x and/or "
|
| 261 |
|
|
"0x%x corrupt!\n", ino->i_number, mftno);
|
| 262 |
|
|
ntfs_free(mft);
|
| 263 |
|
|
return -EINVAL; /* FIXME: Better error code? (AIA) */
|
| 264 |
|
|
}
|
| 265 |
|
|
error = ntfs_insert_mft_attribute(ino, mftno, attr);
|
| 266 |
|
|
if (error) {
|
| 267 |
|
|
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
|
| 268 |
|
|
"ntfs_insert_mft_attribute(mftno 0x%x, "
|
| 269 |
|
|
"attribute type 0x%x) failed\n", mftno,
|
| 270 |
|
|
NTFS_GETU32(alist + 0));
|
| 271 |
|
|
ntfs_free(mft);
|
| 272 |
|
|
return error;
|
| 273 |
|
|
}
|
| 274 |
|
|
len -= l;
|
| 275 |
|
|
alist += l;
|
| 276 |
|
|
}
|
| 277 |
|
|
ntfs_free(mft);
|
| 278 |
|
|
*plen = len;
|
| 279 |
|
|
return 0;
|
| 280 |
|
|
force_load_mft_data:
|
| 281 |
|
|
{
|
| 282 |
|
|
ntfs_u8 *mft2, *attr2;
|
| 283 |
|
|
int mftno2;
|
| 284 |
|
|
int last_mft2 = last_mft;
|
| 285 |
|
|
int len2 = len;
|
| 286 |
|
|
int error2;
|
| 287 |
|
|
int found2 = 0;
|
| 288 |
|
|
ntfs_u8 *alist2 = alist;
|
| 289 |
|
|
/*
|
| 290 |
|
|
* We only get here if $DATA wasn't found in $MFT which only happens
|
| 291 |
|
|
* on volume mount when $MFT has an attribute list and there are
|
| 292 |
|
|
* attributes before $DATA which are inside extent mft records. So
|
| 293 |
|
|
* we just skip forward to the $DATA attribute and read that. Then we
|
| 294 |
|
|
* restart which is safe as an attribute will not be inserted twice.
|
| 295 |
|
|
*
|
| 296 |
|
|
* This still will not fix the case where the attribute list is non-
|
| 297 |
|
|
* resident, larger than 1024 bytes, and the $DATA attribute list entry
|
| 298 |
|
|
* is not in the first 1024 bytes. FIXME: This should be implemented
|
| 299 |
|
|
* somehow! Perhaps by passing special error code up to
|
| 300 |
|
|
* ntfs_load_attributes() so it keeps going trying to get to $DATA
|
| 301 |
|
|
* regardless. Then it would have to restart just like we do here.
|
| 302 |
|
|
*/
|
| 303 |
|
|
mft2 = ntfs_malloc(ino->vol->mft_record_size);
|
| 304 |
|
|
if (!mft2) {
|
| 305 |
|
|
ntfs_free(mft);
|
| 306 |
|
|
return -ENOMEM;
|
| 307 |
|
|
}
|
| 308 |
|
|
ntfs_memcpy(mft2, mft, ino->vol->mft_record_size);
|
| 309 |
|
|
while (len2 > 8) {
|
| 310 |
|
|
l = NTFS_GETU16(alist2 + 4);
|
| 311 |
|
|
if (l > len2)
|
| 312 |
|
|
break;
|
| 313 |
|
|
if (NTFS_GETU32(alist2 + 0x0) < ino->vol->at_data) {
|
| 314 |
|
|
len2 -= l;
|
| 315 |
|
|
alist2 += l;
|
| 316 |
|
|
continue;
|
| 317 |
|
|
}
|
| 318 |
|
|
if (NTFS_GETU32(alist2 + 0x0) > ino->vol->at_data) {
|
| 319 |
|
|
if (found2)
|
| 320 |
|
|
break;
|
| 321 |
|
|
/* Uh-oh! It really isn't there! */
|
| 322 |
|
|
ntfs_error("Either the $MFT is corrupt or, equally "
|
| 323 |
|
|
"likely, the $MFT is too complex for "
|
| 324 |
|
|
"the current driver to handle. Please "
|
| 325 |
|
|
"email the ntfs maintainer that you "
|
| 326 |
|
|
"saw this message. Thank you.\n");
|
| 327 |
|
|
goto failed_reading_mft_data;
|
| 328 |
|
|
}
|
| 329 |
|
|
/* Process attribute description. */
|
| 330 |
|
|
mftno2 = NTFS_GETU32(alist2 + 0x10);
|
| 331 |
|
|
if (mftno2 != ino->i_number && mftno2 != last_mft2) {
|
| 332 |
|
|
last_mft2 = mftno2;
|
| 333 |
|
|
error2 = ntfs_read_mft_record(ino->vol, mftno2, mft2);
|
| 334 |
|
|
if (error2) {
|
| 335 |
|
|
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
|
| 336 |
|
|
"ntfs_read_mft_record(mftno2 = 0x%x) "
|
| 337 |
|
|
"failed\n", mftno2);
|
| 338 |
|
|
ntfs_free(mft2);
|
| 339 |
|
|
goto failed_reading_mft_data;
|
| 340 |
|
|
}
|
| 341 |
|
|
}
|
| 342 |
|
|
attr2 = ntfs_find_attr_in_mft_rec(
|
| 343 |
|
|
ino->vol, /* ntfs volume */
|
| 344 |
|
|
mftno2 == ino->i_number ?/* mft record is: */
|
| 345 |
|
|
ino->attr: /* base record */
|
| 346 |
|
|
mft2, /* extension record */
|
| 347 |
|
|
NTFS_GETU32(alist2 + 0), /* type */
|
| 348 |
|
|
(wchar_t*)(alist2 + alist2[7]), /* name */
|
| 349 |
|
|
alist2[6], /* name length */
|
| 350 |
|
|
1, /* ignore case */
|
| 351 |
|
|
NTFS_GETU16(alist2 + 24) /* instance number */
|
| 352 |
|
|
);
|
| 353 |
|
|
if (!attr2) {
|
| 354 |
|
|
ntfs_error("parse_attributes: mft records 0x%x and/or "
|
| 355 |
|
|
"0x%x corrupt!\n", ino->i_number,
|
| 356 |
|
|
mftno2);
|
| 357 |
|
|
ntfs_free(mft2);
|
| 358 |
|
|
goto failed_reading_mft_data;
|
| 359 |
|
|
}
|
| 360 |
|
|
error2 = ntfs_insert_mft_attribute(ino, mftno2, attr2);
|
| 361 |
|
|
if (error2) {
|
| 362 |
|
|
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
|
| 363 |
|
|
"ntfs_insert_mft_attribute(mftno2 0x%x, "
|
| 364 |
|
|
"attribute2 type 0x%x) failed\n", mftno2,
|
| 365 |
|
|
NTFS_GETU32(alist2 + 0));
|
| 366 |
|
|
ntfs_free(mft2);
|
| 367 |
|
|
goto failed_reading_mft_data;
|
| 368 |
|
|
}
|
| 369 |
|
|
len2 -= l;
|
| 370 |
|
|
alist2 += l;
|
| 371 |
|
|
found2 = 1;
|
| 372 |
|
|
}
|
| 373 |
|
|
ntfs_free(mft2);
|
| 374 |
|
|
tries = 1;
|
| 375 |
|
|
goto continue_after_loading_mft_data;
|
| 376 |
|
|
}
|
| 377 |
|
|
}
|
| 378 |
|
|
|
| 379 |
|
|
static void ntfs_load_attributes(ntfs_inode *ino)
|
| 380 |
|
|
{
|
| 381 |
|
|
ntfs_attribute *alist;
|
| 382 |
|
|
int datasize;
|
| 383 |
|
|
int offset, len, delta;
|
| 384 |
|
|
char *buf;
|
| 385 |
|
|
ntfs_volume *vol = ino->vol;
|
| 386 |
|
|
|
| 387 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 1\n", ino->i_number);
|
| 388 |
|
|
if (ntfs_insert_mft_attributes(ino, ino->attr, ino->i_number))
|
| 389 |
|
|
return;
|
| 390 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 2\n", ino->i_number);
|
| 391 |
|
|
alist = ntfs_find_attr(ino, vol->at_attribute_list, 0);
|
| 392 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 3\n", ino->i_number);
|
| 393 |
|
|
if (!alist)
|
| 394 |
|
|
return;
|
| 395 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 4\n", ino->i_number);
|
| 396 |
|
|
datasize = alist->size;
|
| 397 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: alist->size = 0x%x\n",
|
| 398 |
|
|
ino->i_number, alist->size);
|
| 399 |
|
|
if (alist->resident) {
|
| 400 |
|
|
parse_attributes(ino, alist->d.data, &datasize);
|
| 401 |
|
|
return;
|
| 402 |
|
|
}
|
| 403 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 5\n", ino->i_number);
|
| 404 |
|
|
buf = ntfs_malloc(1024);
|
| 405 |
|
|
if (!buf) /* FIXME: Should be passing error code to caller. (AIA) */
|
| 406 |
|
|
return;
|
| 407 |
|
|
delta = 0;
|
| 408 |
|
|
for (offset = 0; datasize; datasize -= len, offset += len) {
|
| 409 |
|
|
ntfs_io io;
|
| 410 |
|
|
|
| 411 |
|
|
io.fn_put = ntfs_put;
|
| 412 |
|
|
io.fn_get = 0;
|
| 413 |
|
|
io.param = buf + delta;
|
| 414 |
|
|
len = 1024 - delta;
|
| 415 |
|
|
if (len > datasize)
|
| 416 |
|
|
len = datasize;
|
| 417 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: len = %i\n",
|
| 418 |
|
|
ino->i_number, len);
|
| 419 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: delta = %i\n",
|
| 420 |
|
|
ino->i_number, delta);
|
| 421 |
|
|
io.size = len;
|
| 422 |
|
|
if (ntfs_read_attr(ino, vol->at_attribute_list, 0, offset,
|
| 423 |
|
|
&io))
|
| 424 |
|
|
ntfs_error("error in load_attributes\n");
|
| 425 |
|
|
delta += len;
|
| 426 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: after += len, "
|
| 427 |
|
|
"delta = %i\n", ino->i_number, delta);
|
| 428 |
|
|
parse_attributes(ino, buf, &delta);
|
| 429 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: after "
|
| 430 |
|
|
"parse_attr, delta = %i\n", ino->i_number,
|
| 431 |
|
|
delta);
|
| 432 |
|
|
if (delta)
|
| 433 |
|
|
/* Move remaining bytes to buffer start. */
|
| 434 |
|
|
ntfs_memmove(buf, buf + len - delta, delta);
|
| 435 |
|
|
}
|
| 436 |
|
|
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 6\n", ino->i_number);
|
| 437 |
|
|
ntfs_free(buf);
|
| 438 |
|
|
}
|
| 439 |
|
|
|
| 440 |
|
|
int ntfs_init_inode(ntfs_inode *ino, ntfs_volume *vol, int inum)
|
| 441 |
|
|
{
|
| 442 |
|
|
char *buf;
|
| 443 |
|
|
int error;
|
| 444 |
|
|
|
| 445 |
|
|
ntfs_debug(DEBUG_FILE1, "Initializing inode 0x%x\n", inum);
|
| 446 |
|
|
ino->i_number = inum;
|
| 447 |
|
|
ino->vol = vol;
|
| 448 |
|
|
ino->attr = buf = ntfs_malloc(vol->mft_record_size);
|
| 449 |
|
|
if (!buf)
|
| 450 |
|
|
return -ENOMEM;
|
| 451 |
|
|
error = ntfs_read_mft_record(vol, inum, ino->attr);
|
| 452 |
|
|
if (error) {
|
| 453 |
|
|
ntfs_debug(DEBUG_OTHER, "Init inode: 0x%x failed\n", inum);
|
| 454 |
|
|
return error;
|
| 455 |
|
|
}
|
| 456 |
|
|
ntfs_debug(DEBUG_FILE2, "Init inode: got mft 0x%x\n", inum);
|
| 457 |
|
|
ino->sequence_number = NTFS_GETU16(buf + 0x10);
|
| 458 |
|
|
ino->attr_count = 0;
|
| 459 |
|
|
ino->record_count = 0;
|
| 460 |
|
|
ino->records = 0;
|
| 461 |
|
|
ino->attrs = 0;
|
| 462 |
|
|
ntfs_load_attributes(ino);
|
| 463 |
|
|
ntfs_debug(DEBUG_FILE2, "Init inode: done 0x%x\n", inum);
|
| 464 |
|
|
return 0;
|
| 465 |
|
|
}
|
| 466 |
|
|
|
| 467 |
|
|
void ntfs_clear_inode(ntfs_inode *ino)
|
| 468 |
|
|
{
|
| 469 |
|
|
int i;
|
| 470 |
|
|
if (!ino->attr) {
|
| 471 |
|
|
ntfs_error("ntfs_clear_inode: double free\n");
|
| 472 |
|
|
return;
|
| 473 |
|
|
}
|
| 474 |
|
|
ntfs_free(ino->attr);
|
| 475 |
|
|
ino->attr = 0;
|
| 476 |
|
|
ntfs_free(ino->records);
|
| 477 |
|
|
ino->records = 0;
|
| 478 |
|
|
for (i = 0; i < ino->attr_count; i++) {
|
| 479 |
|
|
if (ino->attrs[i].name)
|
| 480 |
|
|
ntfs_free(ino->attrs[i].name);
|
| 481 |
|
|
if (ino->attrs[i].resident) {
|
| 482 |
|
|
if (ino->attrs[i].d.data)
|
| 483 |
|
|
ntfs_free(ino->attrs[i].d.data);
|
| 484 |
|
|
} else {
|
| 485 |
|
|
if (ino->attrs[i].d.r.runlist)
|
| 486 |
|
|
ntfs_vfree(ino->attrs[i].d.r.runlist);
|
| 487 |
|
|
}
|
| 488 |
|
|
}
|
| 489 |
|
|
ntfs_free(ino->attrs);
|
| 490 |
|
|
ino->attrs = 0;
|
| 491 |
|
|
}
|
| 492 |
|
|
|
| 493 |
|
|
/* Check and fixup a MFT record. */
|
| 494 |
|
|
int ntfs_check_mft_record(ntfs_volume *vol, char *record)
|
| 495 |
|
|
{
|
| 496 |
|
|
return ntfs_fixup_record(record, "FILE", vol->mft_record_size);
|
| 497 |
|
|
}
|
| 498 |
|
|
|
| 499 |
|
|
/* Return (in result) the value indicating the next available attribute
|
| 500 |
|
|
* chunk number. Works for inodes w/o extension records only. */
|
| 501 |
|
|
int ntfs_allocate_attr_number(ntfs_inode *ino, int *result)
|
| 502 |
|
|
{
|
| 503 |
|
|
if (ino->record_count != 1)
|
| 504 |
|
|
return -EOPNOTSUPP;
|
| 505 |
|
|
*result = NTFS_GETU16(ino->attr + 0x28);
|
| 506 |
|
|
NTFS_PUTU16(ino->attr + 0x28, (*result) + 1);
|
| 507 |
|
|
return 0;
|
| 508 |
|
|
}
|
| 509 |
|
|
|
| 510 |
|
|
/* Find the location of an attribute in the inode. A name of NULL indicates
|
| 511 |
|
|
* unnamed attributes. Return pointer to attribute or NULL if not found. */
|
| 512 |
|
|
char *ntfs_get_attr(ntfs_inode *ino, int attr, char *name)
|
| 513 |
|
|
{
|
| 514 |
|
|
/* Location of first attribute. */
|
| 515 |
|
|
char *it = ino->attr + NTFS_GETU16(ino->attr + 0x14);
|
| 516 |
|
|
int type;
|
| 517 |
|
|
int len;
|
| 518 |
|
|
|
| 519 |
|
|
/* Only check for magic DWORD here, fixup should have happened before.*/
|
| 520 |
|
|
if (!IS_MFT_RECORD(ino->attr))
|
| 521 |
|
|
return 0;
|
| 522 |
|
|
do {
|
| 523 |
|
|
type = NTFS_GETU32(it);
|
| 524 |
|
|
len = NTFS_GETU16(it + 4);
|
| 525 |
|
|
/* We found the attribute type. Is the name correct, too? */
|
| 526 |
|
|
if (type == attr) {
|
| 527 |
|
|
int namelen = NTFS_GETU8(it + 9);
|
| 528 |
|
|
char *name_it, *n = name;
|
| 529 |
|
|
/* Match given name and attribute name if present.
|
| 530 |
|
|
Make sure attribute name is Unicode. */
|
| 531 |
|
|
if (!name) {
|
| 532 |
|
|
goto check_namelen;
|
| 533 |
|
|
} else if (namelen) {
|
| 534 |
|
|
for (name_it = it + NTFS_GETU16(it + 10);
|
| 535 |
|
|
namelen; n++, name_it += 2, namelen--)
|
| 536 |
|
|
if (*name_it != *n || name_it[1])
|
| 537 |
|
|
break;
|
| 538 |
|
|
check_namelen:
|
| 539 |
|
|
if (!namelen)
|
| 540 |
|
|
break;
|
| 541 |
|
|
}
|
| 542 |
|
|
}
|
| 543 |
|
|
it += len;
|
| 544 |
|
|
} while (type != -1); /* List of attributes ends with type -1. */
|
| 545 |
|
|
if (type == -1)
|
| 546 |
|
|
return 0;
|
| 547 |
|
|
return it;
|
| 548 |
|
|
}
|
| 549 |
|
|
|
| 550 |
|
|
__s64 ntfs_get_attr_size(ntfs_inode *ino, int type, char *name)
|
| 551 |
|
|
{
|
| 552 |
|
|
ntfs_attribute *attr = ntfs_find_attr(ino, type, name);
|
| 553 |
|
|
if (!attr)
|
| 554 |
|
|
return 0;
|
| 555 |
|
|
return
|
| 556 |
|
|
attr->size;
|
| 557 |
|
|
}
|
| 558 |
|
|
|
| 559 |
|
|
int ntfs_attr_is_resident(ntfs_inode *ino, int type, char *name)
|
| 560 |
|
|
{
|
| 561 |
|
|
ntfs_attribute *attr = ntfs_find_attr(ino, type, name);
|
| 562 |
|
|
if (!attr)
|
| 563 |
|
|
return 0;
|
| 564 |
|
|
return attr->resident;
|
| 565 |
|
|
}
|
| 566 |
|
|
|
| 567 |
|
|
/*
|
| 568 |
|
|
* A run is coded as a type indicator, an unsigned length, and a signed cluster
|
| 569 |
|
|
* offset.
|
| 570 |
|
|
* . To save space, length and offset are fields of variable length. The low
|
| 571 |
|
|
* nibble of the type indicates the width of the length :), the high nibble
|
| 572 |
|
|
* the width of the offset.
|
| 573 |
|
|
* . The first offset is relative to cluster 0, later offsets are relative to
|
| 574 |
|
|
* the previous cluster.
|
| 575 |
|
|
*
|
| 576 |
|
|
* This function decodes a run. Length is an output parameter, data and cluster
|
| 577 |
|
|
* are in/out parameters.
|
| 578 |
|
|
*/
|
| 579 |
|
|
int ntfs_decompress_run(unsigned char **data, int *length,
|
| 580 |
|
|
ntfs_cluster_t *cluster, int *ctype)
|
| 581 |
|
|
{
|
| 582 |
|
|
unsigned char type = *(*data)++;
|
| 583 |
|
|
*ctype = 0;
|
| 584 |
|
|
switch (type & 0xF) {
|
| 585 |
|
|
case 1:
|
| 586 |
|
|
*length = NTFS_GETS8(*data);
|
| 587 |
|
|
break;
|
| 588 |
|
|
case 2:
|
| 589 |
|
|
*length = NTFS_GETS16(*data);
|
| 590 |
|
|
break;
|
| 591 |
|
|
case 3:
|
| 592 |
|
|
*length = NTFS_GETS24(*data);
|
| 593 |
|
|
break;
|
| 594 |
|
|
case 4:
|
| 595 |
|
|
*length = NTFS_GETS32(*data);
|
| 596 |
|
|
break;
|
| 597 |
|
|
/* Note: cases 5-8 are probably pointless to code, since how
|
| 598 |
|
|
* many runs > 4GB of length are there? At the most, cases 5
|
| 599 |
|
|
* and 6 are probably necessary, and would also require making
|
| 600 |
|
|
* length 64-bit throughout. */
|
| 601 |
|
|
default:
|
| 602 |
|
|
ntfs_error("Can't decode run type field 0x%x\n", type);
|
| 603 |
|
|
return -1;
|
| 604 |
|
|
}
|
| 605 |
|
|
// ntfs_debug(DEBUG_FILE3, "ntfs_decompress_run: length = 0x%x\n",*length);
|
| 606 |
|
|
if (*length < 0)
|
| 607 |
|
|
{
|
| 608 |
|
|
ntfs_error("Negative run length decoded\n");
|
| 609 |
|
|
return -1;
|
| 610 |
|
|
}
|
| 611 |
|
|
*data += (type & 0xF);
|
| 612 |
|
|
switch (type & 0xF0) {
|
| 613 |
|
|
case 0:
|
| 614 |
|
|
*ctype = 2;
|
| 615 |
|
|
break;
|
| 616 |
|
|
case 0x10:
|
| 617 |
|
|
*cluster += NTFS_GETS8(*data);
|
| 618 |
|
|
break;
|
| 619 |
|
|
case 0x20:
|
| 620 |
|
|
*cluster += NTFS_GETS16(*data);
|
| 621 |
|
|
break;
|
| 622 |
|
|
case 0x30:
|
| 623 |
|
|
*cluster += NTFS_GETS24(*data);
|
| 624 |
|
|
break;
|
| 625 |
|
|
case 0x40:
|
| 626 |
|
|
*cluster += NTFS_GETS32(*data);
|
| 627 |
|
|
break;
|
| 628 |
|
|
#if 0 /* Keep for future, in case ntfs_cluster_t ever becomes 64bit. */
|
| 629 |
|
|
case 0x50:
|
| 630 |
|
|
*cluster += NTFS_GETS40(*data);
|
| 631 |
|
|
break;
|
| 632 |
|
|
case 0x60:
|
| 633 |
|
|
*cluster += NTFS_GETS48(*data);
|
| 634 |
|
|
break;
|
| 635 |
|
|
case 0x70:
|
| 636 |
|
|
*cluster += NTFS_GETS56(*data);
|
| 637 |
|
|
break;
|
| 638 |
|
|
case 0x80:
|
| 639 |
|
|
*cluster += NTFS_GETS64(*data);
|
| 640 |
|
|
break;
|
| 641 |
|
|
#endif
|
| 642 |
|
|
default:
|
| 643 |
|
|
ntfs_error("Can't decode run type field 0x%x\n", type);
|
| 644 |
|
|
return -1;
|
| 645 |
|
|
}
|
| 646 |
|
|
// ntfs_debug(DEBUG_FILE3, "ntfs_decompress_run: cluster = 0x%x\n",
|
| 647 |
|
|
// *cluster);
|
| 648 |
|
|
*data += (type >> 4);
|
| 649 |
|
|
return 0;
|
| 650 |
|
|
}
|
| 651 |
|
|
|
| 652 |
|
|
static void dump_runlist(const ntfs_runlist *rl, const int rlen);
|
| 653 |
|
|
|
| 654 |
|
|
/*
|
| 655 |
|
|
* FIXME: ntfs_readwrite_attr() has the effect of writing @dest to @offset of
|
| 656 |
|
|
* the attribute value of the attribute @attr in the in memory inode @ino.
|
| 657 |
|
|
* If the attribute value of @attr is non-resident the value's contents at
|
| 658 |
|
|
* @offset are actually written to disk (from @dest). The on disk mft record
|
| 659 |
|
|
* describing the non-resident attribute value is not updated!
|
| 660 |
|
|
* If the attribute value is resident then the value is written only in
|
| 661 |
|
|
* memory. The on disk mft record containing the value is not written to disk.
|
| 662 |
|
|
* A possible fix would be to call ntfs_update_inode() before returning. (AIA)
|
| 663 |
|
|
*/
|
| 664 |
|
|
/* Reads l bytes of the attribute (attr, name) of ino starting at offset on
|
| 665 |
|
|
* vol into buf. Returns the number of bytes read in the ntfs_io struct.
|
| 666 |
|
|
* Returns 0 on success, errno on failure */
|
| 667 |
|
|
int ntfs_readwrite_attr(ntfs_inode *ino, ntfs_attribute *attr, __s64 offset,
|
| 668 |
|
|
ntfs_io *dest)
|
| 669 |
|
|
{
|
| 670 |
|
|
int rnum, s_vcn, error, clustersizebits;
|
| 671 |
|
|
ntfs_cluster_t cluster, s_cluster, vcn, len;
|
| 672 |
|
|
__s64 l, chunk, copied;
|
| 673 |
|
|
|
| 674 |
|
|
ntfs_debug(DEBUG_FILE3, "%s(): %s 0x%x bytes at offset "
|
| 675 |
|
|
"0x%Lx %s inode 0x%x, attr type 0x%x.\n", __FUNCTION__,
|
| 676 |
|
|
dest->do_read ? "Read" : "Write", dest->size, offset,
|
| 677 |
|
|
dest->do_read ? "from" : "to", ino->i_number,
|
| 678 |
|
|
attr->type);
|
| 679 |
|
|
l = dest->size;
|
| 680 |
|
|
if (l == 0)
|
| 681 |
|
|
return 0;
|
| 682 |
|
|
if (dest->do_read) {
|
| 683 |
|
|
/* If read _starts_ beyond end of stream, return nothing. */
|
| 684 |
|
|
if (offset >= attr->size) {
|
| 685 |
|
|
dest->size = 0;
|
| 686 |
|
|
return 0;
|
| 687 |
|
|
}
|
| 688 |
|
|
/* If read _extends_ beyond end of stream, return as much
|
| 689 |
|
|
* initialised data as we have. */
|
| 690 |
|
|
if (offset + l >= attr->size)
|
| 691 |
|
|
l = dest->size = attr->size - offset;
|
| 692 |
|
|
} else {
|
| 693 |
|
|
/*
|
| 694 |
|
|
* If write extends beyond _allocated_ size, extend attribute,
|
| 695 |
|
|
* updating attr->allocated and attr->size in the process. (AIA)
|
| 696 |
|
|
*/
|
| 697 |
|
|
if ((!attr->resident && offset + l > attr->allocated) ||
|
| 698 |
|
|
(attr->resident && offset + l > attr->size)) {
|
| 699 |
|
|
error = ntfs_resize_attr(ino, attr, offset + l);
|
| 700 |
|
|
if (error)
|
| 701 |
|
|
return error;
|
| 702 |
|
|
}
|
| 703 |
|
|
if (!attr->resident) {
|
| 704 |
|
|
/* Has amount of data increased? */
|
| 705 |
|
|
if (offset + l > attr->size)
|
| 706 |
|
|
attr->size = offset + l;
|
| 707 |
|
|
/* Has amount of initialised data increased? */
|
| 708 |
|
|
if (offset + l > attr->initialized) {
|
| 709 |
|
|
/* FIXME: Clear the section between the old
|
| 710 |
|
|
* initialised length and the write start.
|
| 711 |
|
|
* (AIA) */
|
| 712 |
|
|
attr->initialized = offset + l;
|
| 713 |
|
|
}
|
| 714 |
|
|
}
|
| 715 |
|
|
}
|
| 716 |
|
|
if (attr->resident) {
|
| 717 |
|
|
if (dest->do_read)
|
| 718 |
|
|
dest->fn_put(dest, (ntfs_u8*)attr->d.data + offset, l);
|
| 719 |
|
|
else
|
| 720 |
|
|
dest->fn_get((ntfs_u8*)attr->d.data + offset, dest, l);
|
| 721 |
|
|
dest->size = l;
|
| 722 |
|
|
return 0;
|
| 723 |
|
|
}
|
| 724 |
|
|
if (dest->do_read) {
|
| 725 |
|
|
/* Read uninitialized data. */
|
| 726 |
|
|
if (offset >= attr->initialized)
|
| 727 |
|
|
return ntfs_read_zero(dest, l);
|
| 728 |
|
|
if (offset + l > attr->initialized) {
|
| 729 |
|
|
dest->size = chunk = attr->initialized - offset;
|
| 730 |
|
|
error = ntfs_readwrite_attr(ino, attr, offset, dest);
|
| 731 |
|
|
if (error || (dest->size != chunk && (error = -EIO, 1)))
|
| 732 |
|
|
return error;
|
| 733 |
|
|
dest->size += l - chunk;
|
| 734 |
|
|
return ntfs_read_zero(dest, l - chunk);
|
| 735 |
|
|
}
|
| 736 |
|
|
if (attr->flags & ATTR_IS_COMPRESSED)
|
| 737 |
|
|
return ntfs_read_compressed(ino, attr, offset, dest);
|
| 738 |
|
|
} else {
|
| 739 |
|
|
if (attr->flags & ATTR_IS_COMPRESSED)
|
| 740 |
|
|
return ntfs_write_compressed(ino, attr, offset, dest);
|
| 741 |
|
|
}
|
| 742 |
|
|
vcn = 0;
|
| 743 |
|
|
clustersizebits = ino->vol->cluster_size_bits;
|
| 744 |
|
|
s_vcn = offset >> clustersizebits;
|
| 745 |
|
|
for (rnum = 0; rnum < attr->d.r.len &&
|
| 746 |
|
|
vcn + attr->d.r.runlist[rnum].len <= s_vcn; rnum++)
|
| 747 |
|
|
vcn += attr->d.r.runlist[rnum].len;
|
| 748 |
|
|
if (rnum == attr->d.r.len) {
|
| 749 |
|
|
ntfs_debug(DEBUG_FILE3, "%s(): EOPNOTSUPP: "
|
| 750 |
|
|
"inode = 0x%x, rnum = %i, offset = 0x%Lx, vcn = 0x%x, "
|
| 751 |
|
|
"s_vcn = 0x%x.\n", __FUNCTION__, ino->i_number, rnum,
|
| 752 |
|
|
offset, vcn, s_vcn);
|
| 753 |
|
|
dump_runlist(attr->d.r.runlist, attr->d.r.len);
|
| 754 |
|
|
/*FIXME: Should extend runlist. */
|
| 755 |
|
|
return -EOPNOTSUPP;
|
| 756 |
|
|
}
|
| 757 |
|
|
copied = 0;
|
| 758 |
|
|
while (l) {
|
| 759 |
|
|
s_vcn = offset >> clustersizebits;
|
| 760 |
|
|
cluster = attr->d.r.runlist[rnum].lcn;
|
| 761 |
|
|
len = attr->d.r.runlist[rnum].len;
|
| 762 |
|
|
s_cluster = cluster + s_vcn - vcn;
|
| 763 |
|
|
chunk = ((__s64)(vcn + len) << clustersizebits) - offset;
|
| 764 |
|
|
if (chunk > l)
|
| 765 |
|
|
chunk = l;
|
| 766 |
|
|
dest->size = chunk;
|
| 767 |
|
|
error = ntfs_getput_clusters(ino->vol, s_cluster, offset -
|
| 768 |
|
|
((__s64)s_vcn << clustersizebits), dest);
|
| 769 |
|
|
if (error) {
|
| 770 |
|
|
ntfs_error("Read/write error.\n");
|
| 771 |
|
|
dest->size = copied;
|
| 772 |
|
|
return error;
|
| 773 |
|
|
}
|
| 774 |
|
|
l -= chunk;
|
| 775 |
|
|
copied += chunk;
|
| 776 |
|
|
offset += chunk;
|
| 777 |
|
|
if (l && offset >= ((__s64)(vcn + len) << clustersizebits)) {
|
| 778 |
|
|
rnum++;
|
| 779 |
|
|
vcn += len;
|
| 780 |
|
|
cluster = attr->d.r.runlist[rnum].lcn;
|
| 781 |
|
|
len = attr->d.r.runlist[rnum].len;
|
| 782 |
|
|
}
|
| 783 |
|
|
}
|
| 784 |
|
|
dest->size = copied;
|
| 785 |
|
|
return 0;
|
| 786 |
|
|
}
|
| 787 |
|
|
|
| 788 |
|
|
int ntfs_read_attr(ntfs_inode *ino, int type, char *name, __s64 offset,
|
| 789 |
|
|
ntfs_io *buf)
|
| 790 |
|
|
{
|
| 791 |
|
|
ntfs_attribute *attr;
|
| 792 |
|
|
|
| 793 |
|
|
buf->do_read = 1;
|
| 794 |
|
|
attr = ntfs_find_attr(ino, type, name);
|
| 795 |
|
|
if (!attr) {
|
| 796 |
|
|
ntfs_debug(DEBUG_FILE3, "%s(): attr 0x%x not found in inode "
|
| 797 |
|
|
"0x%x\n", __FUNCTION__, type, ino->i_number);
|
| 798 |
|
|
return -EINVAL;
|
| 799 |
|
|
}
|
| 800 |
|
|
return ntfs_readwrite_attr(ino, attr, offset, buf);
|
| 801 |
|
|
}
|
| 802 |
|
|
|
| 803 |
|
|
int ntfs_write_attr(ntfs_inode *ino, int type, char *name, __s64 offset,
|
| 804 |
|
|
ntfs_io *buf)
|
| 805 |
|
|
{
|
| 806 |
|
|
ntfs_attribute *attr;
|
| 807 |
|
|
|
| 808 |
|
|
buf->do_read = 0;
|
| 809 |
|
|
attr = ntfs_find_attr(ino, type, name);
|
| 810 |
|
|
if (!attr) {
|
| 811 |
|
|
ntfs_debug(DEBUG_FILE3, "%s(): attr 0x%x not found in inode "
|
| 812 |
|
|
"0x%x\n", __FUNCTION__, type, ino->i_number);
|
| 813 |
|
|
return -EINVAL;
|
| 814 |
|
|
}
|
| 815 |
|
|
return ntfs_readwrite_attr(ino, attr, offset, buf);
|
| 816 |
|
|
}
|
| 817 |
|
|
|
| 818 |
|
|
/* -2 = error, -1 = hole, >= 0 means real disk cluster (lcn). */
|
| 819 |
|
|
int ntfs_vcn_to_lcn(ntfs_inode *ino, int vcn)
|
| 820 |
|
|
{
|
| 821 |
|
|
int rnum;
|
| 822 |
|
|
ntfs_attribute *data;
|
| 823 |
|
|
|
| 824 |
|
|
data = ntfs_find_attr(ino, ino->vol->at_data, 0);
|
| 825 |
|
|
if (!data || data->resident || data->flags & (ATTR_IS_COMPRESSED |
|
| 826 |
|
|
ATTR_IS_ENCRYPTED))
|
| 827 |
|
|
return -2;
|
| 828 |
|
|
if (data->size <= (__s64)vcn << ino->vol->cluster_size_bits)
|
| 829 |
|
|
return -2;
|
| 830 |
|
|
if (data->initialized <= (__s64)vcn << ino->vol->cluster_size_bits)
|
| 831 |
|
|
return -1;
|
| 832 |
|
|
for (rnum = 0; rnum < data->d.r.len &&
|
| 833 |
|
|
vcn >= data->d.r.runlist[rnum].len; rnum++)
|
| 834 |
|
|
vcn -= data->d.r.runlist[rnum].len;
|
| 835 |
|
|
if (data->d.r.runlist[rnum].lcn >= 0)
|
| 836 |
|
|
return data->d.r.runlist[rnum].lcn + vcn;
|
| 837 |
|
|
return data->d.r.runlist[rnum].lcn + vcn;
|
| 838 |
|
|
}
|
| 839 |
|
|
|
| 840 |
|
|
static int allocate_store(ntfs_volume *vol, ntfs_disk_inode *store, int count)
|
| 841 |
|
|
{
|
| 842 |
|
|
int i;
|
| 843 |
|
|
|
| 844 |
|
|
if (store->count > count)
|
| 845 |
|
|
return 0;
|
| 846 |
|
|
if (store->size < count) {
|
| 847 |
|
|
ntfs_mft_record *n = ntfs_malloc((count + 4) *
|
| 848 |
|
|
sizeof(ntfs_mft_record));
|
| 849 |
|
|
if (!n)
|
| 850 |
|
|
return -ENOMEM;
|
| 851 |
|
|
if (store->size) {
|
| 852 |
|
|
for (i = 0; i < store->size; i++)
|
| 853 |
|
|
n[i] = store->records[i];
|
| 854 |
|
|
ntfs_free(store->records);
|
| 855 |
|
|
}
|
| 856 |
|
|
store->size = count + 4;
|
| 857 |
|
|
store->records = n;
|
| 858 |
|
|
}
|
| 859 |
|
|
for (i = store->count; i < count; i++) {
|
| 860 |
|
|
store->records[i].record = ntfs_malloc(vol->mft_record_size);
|
| 861 |
|
|
if (!store->records[i].record)
|
| 862 |
|
|
return -ENOMEM;
|
| 863 |
|
|
store->count++;
|
| 864 |
|
|
}
|
| 865 |
|
|
return 0;
|
| 866 |
|
|
}
|
| 867 |
|
|
|
| 868 |
|
|
static void deallocate_store(ntfs_disk_inode* store)
|
| 869 |
|
|
{
|
| 870 |
|
|
int i;
|
| 871 |
|
|
|
| 872 |
|
|
for (i = 0; i < store->count; i++)
|
| 873 |
|
|
ntfs_free(store->records[i].record);
|
| 874 |
|
|
ntfs_free(store->records);
|
| 875 |
|
|
store->count = store->size = 0;
|
| 876 |
|
|
store->records = 0;
|
| 877 |
|
|
}
|
| 878 |
|
|
|
| 879 |
|
|
/**
|
| 880 |
|
|
* layout_runs - compress runlist into mapping pairs array
|
| 881 |
|
|
* @attr: attribute containing the runlist to compress
|
| 882 |
|
|
* @rec: destination buffer to hold the mapping pairs array
|
| 883 |
|
|
* @offs: current position in @rec (in/out variable)
|
| 884 |
|
|
* @size: size of the buffer @rec
|
| 885 |
|
|
*
|
| 886 |
|
|
* layout_runs walks the runlist in @attr, compresses it and writes it out the
|
| 887 |
|
|
* resulting mapping pairs array into @rec (up to a maximum of @size bytes are
|
| 888 |
|
|
* written). On entry @offs is the offset in @rec at which to begin writing the
|
| 889 |
|
|
* mapping pairs array. On exit, it contains the offset in @rec of the first
|
| 890 |
|
|
* byte after the end of the mapping pairs array.
|
| 891 |
|
|
*/
|
| 892 |
|
|
static int layout_runs(ntfs_attribute *attr, char *rec, int *offs, int size)
|
| 893 |
|
|
{
|
| 894 |
|
|
int i, len, offset, coffs;
|
| 895 |
|
|
/* ntfs_cluster_t MUST be signed! (AIA) */
|
| 896 |
|
|
ntfs_cluster_t cluster, rclus;
|
| 897 |
|
|
ntfs_runlist *rl = attr->d.r.runlist;
|
| 898 |
|
|
cluster = 0;
|
| 899 |
|
|
offset = *offs;
|
| 900 |
|
|
for (i = 0; i < attr->d.r.len; i++) {
|
| 901 |
|
|
/*
|
| 902 |
|
|
* We cheat with this check on the basis that lcn will never
|
| 903 |
|
|
* be less than -1 and the lcn delta will fit in signed
|
| 904 |
|
|
* 32-bits (ntfs_cluster_t). (AIA)
|
| 905 |
|
|
*/
|
| 906 |
|
|
if (rl[i].lcn < (ntfs_cluster_t)-1) {
|
| 907 |
|
|
ntfs_error("layout_runs() encountered an out of bounds "
|
| 908 |
|
|
"cluster delta, lcn = %i.\n",
|
| 909 |
|
|
rl[i].lcn);
|
| 910 |
|
|
return -ERANGE;
|
| 911 |
|
|
}
|
| 912 |
|
|
rclus = rl[i].lcn - cluster;
|
| 913 |
|
|
len = rl[i].len;
|
| 914 |
|
|
rec[offset] = 0;
|
| 915 |
|
|
if (offset + 9 > size)
|
| 916 |
|
|
return -E2BIG; /* It might still fit, but this
|
| 917 |
|
|
* simplifies testing. */
|
| 918 |
|
|
/*
|
| 919 |
|
|
* Run length is stored as signed number, so deal with it
|
| 920 |
|
|
* properly, i.e. observe that a negative number will have all
|
| 921 |
|
|
* its most significant bits set to 1 but we don't store that
|
| 922 |
|
|
* in the mapping pairs array. We store the smallest type of
|
| 923 |
|
|
* negative number required, thus in the first if we check
|
| 924 |
|
|
* whether len fits inside a signed byte and if so we store it
|
| 925 |
|
|
* as such, the next ifs check for a signed short, then a signed
|
| 926 |
|
|
* 24-bit and finally the full blown signed 32-bit. Same goes
|
| 927 |
|
|
* for rlus below. (AIA)
|
| 928 |
|
|
*/
|
| 929 |
|
|
if (len >= -0x80 && len <= 0x7f) {
|
| 930 |
|
|
NTFS_PUTU8(rec + offset + 1, len & 0xff);
|
| 931 |
|
|
coffs = 1;
|
| 932 |
|
|
} else if (len >= -0x8000 && len <= 0x7fff) {
|
| 933 |
|
|
NTFS_PUTU16(rec + offset + 1, len & 0xffff);
|
| 934 |
|
|
coffs = 2;
|
| 935 |
|
|
} else if (len >= -0x800000 && len <= 0x7fffff) {
|
| 936 |
|
|
NTFS_PUTU24(rec + offset + 1, len & 0xffffff);
|
| 937 |
|
|
coffs = 3;
|
| 938 |
|
|
} else /* if (len >= -0x80000000LL && len <= 0x7fffffff */ {
|
| 939 |
|
|
NTFS_PUTU32(rec + offset + 1, len);
|
| 940 |
|
|
coffs = 4;
|
| 941 |
|
|
} /* else ... FIXME: When len becomes 64-bit we need to extend
|
| 942 |
|
|
* the else if () statements. (AIA) */
|
| 943 |
|
|
*(rec + offset) |= coffs++;
|
| 944 |
|
|
if (rl[i].lcn == (ntfs_cluster_t)-1) /* Compressed run. */
|
| 945 |
|
|
/* Nothing */;
|
| 946 |
|
|
else if (rclus >= -0x80 && rclus <= 0x7f) {
|
| 947 |
|
|
*(rec + offset) |= 0x10;
|
| 948 |
|
|
NTFS_PUTS8(rec + offset + coffs, rclus & 0xff);
|
| 949 |
|
|
coffs += 1;
|
| 950 |
|
|
} else if (rclus >= -0x8000 && rclus <= 0x7fff) {
|
| 951 |
|
|
*(rec + offset) |= 0x20;
|
| 952 |
|
|
NTFS_PUTS16(rec + offset + coffs, rclus & 0xffff);
|
| 953 |
|
|
coffs += 2;
|
| 954 |
|
|
} else if (rclus >= -0x800000 && rclus <= 0x7fffff) {
|
| 955 |
|
|
*(rec + offset) |= 0x30;
|
| 956 |
|
|
NTFS_PUTS24(rec + offset + coffs, rclus & 0xffffff);
|
| 957 |
|
|
coffs += 3;
|
| 958 |
|
|
} else /* if (rclus >= -0x80000000LL && rclus <= 0x7fffffff)*/ {
|
| 959 |
|
|
*(rec + offset) |= 0x40;
|
| 960 |
|
|
NTFS_PUTS32(rec + offset + coffs, rclus
|
| 961 |
|
|
/* & 0xffffffffLL */);
|
| 962 |
|
|
coffs += 4;
|
| 963 |
|
|
} /* FIXME: When rclus becomes 64-bit.
|
| 964 |
|
|
else if (rclus >= -0x8000000000 && rclus <= 0x7FFFFFFFFF) {
|
| 965 |
|
|
*(rec + offset) |= 0x50;
|
| 966 |
|
|
NTFS_PUTS40(rec + offset + coffs, rclus &
|
| 967 |
|
|
0xffffffffffLL);
|
| 968 |
|
|
coffs += 5;
|
| 969 |
|
|
} else if (rclus >= -0x800000000000 &&
|
| 970 |
|
|
rclus <= 0x7FFFFFFFFFFF) {
|
| 971 |
|
|
*(rec + offset) |= 0x60;
|
| 972 |
|
|
NTFS_PUTS48(rec + offset + coffs, rclus &
|
| 973 |
|
|
0xffffffffffffLL);
|
| 974 |
|
|
coffs += 6;
|
| 975 |
|
|
} else if (rclus >= -0x80000000000000 &&
|
| 976 |
|
|
rclus <= 0x7FFFFFFFFFFFFF) {
|
| 977 |
|
|
*(rec + offset) |= 0x70;
|
| 978 |
|
|
NTFS_PUTS56(rec + offset + coffs, rclus &
|
| 979 |
|
|
0xffffffffffffffLL);
|
| 980 |
|
|
coffs += 7;
|
| 981 |
|
|
} else {
|
| 982 |
|
|
*(rec + offset) |= 0x80;
|
| 983 |
|
|
NTFS_PUTS64(rec + offset + coffs, rclus);
|
| 984 |
|
|
coffs += 8;
|
| 985 |
|
|
} */
|
| 986 |
|
|
offset += coffs;
|
| 987 |
|
|
if (rl[i].lcn)
|
| 988 |
|
|
cluster = rl[i].lcn;
|
| 989 |
|
|
}
|
| 990 |
|
|
if (offset >= size)
|
| 991 |
|
|
return -E2BIG;
|
| 992 |
|
|
/* Terminating null. */
|
| 993 |
|
|
*(rec + offset++) = 0;
|
| 994 |
|
|
*offs = offset;
|
| 995 |
|
|
return 0;
|
| 996 |
|
|
}
|
| 997 |
|
|
|
| 998 |
|
|
static void count_runs(ntfs_attribute *attr, char *buf)
|
| 999 |
|
|
{
|
| 1000 |
|
|
ntfs_u32 first, count, last, i;
|
| 1001 |
|
|
|
| 1002 |
|
|
first = 0;
|
| 1003 |
|
|
for (i = 0, count = 0; i < attr->d.r.len; i++)
|
| 1004 |
|
|
count += attr->d.r.runlist[i].len;
|
| 1005 |
|
|
last = first + count - 1;
|
| 1006 |
|
|
NTFS_PUTU64(buf + 0x10, first);
|
| 1007 |
|
|
NTFS_PUTU64(buf + 0x18, last);
|
| 1008 |
|
|
}
|
| 1009 |
|
|
|
| 1010 |
|
|
/**
|
| 1011 |
|
|
* layout_attr - convert in memory attribute to on disk attribute record
|
| 1012 |
|
|
* @attr: in memory attribute to convert
|
| 1013 |
|
|
* @buf: destination buffer for on disk attribute record
|
| 1014 |
|
|
* @size: size of the destination buffer
|
| 1015 |
|
|
* @psize: size of converted on disk attribute record (out variable)
|
| 1016 |
|
|
*
|
| 1017 |
|
|
* layout_attr() takes the attribute @attr and converts it into the appropriate
|
| 1018 |
|
|
* on disk structure, writing it into @buf (up to @size bytes are written).
|
| 1019 |
|
|
*
|
| 1020 |
|
|
* On success we return 0 and set @*psize to the actual byte size of the on-
|
| 1021 |
|
|
* disk attribute that was written into @buf.
|
| 1022 |
|
|
*/
|
| 1023 |
|
|
static int layout_attr(ntfs_attribute *attr, char *buf, int size, int *psize)
|
| 1024 |
|
|
{
|
| 1025 |
|
|
int nameoff, hdrsize, asize;
|
| 1026 |
|
|
|
| 1027 |
|
|
if (attr->resident) {
|
| 1028 |
|
|
nameoff = 0x18;
|
| 1029 |
|
|
hdrsize = (nameoff + 2 * attr->namelen + 7) & ~7;
|
| 1030 |
|
|
asize = (hdrsize + attr->size + 7) & ~7;
|
| 1031 |
|
|
if (size < asize)
|
| 1032 |
|
|
return -E2BIG;
|
| 1033 |
|
|
NTFS_PUTU32(buf + 0x10, attr->size);
|
| 1034 |
|
|
NTFS_PUTU8(buf + 0x16, attr->indexed);
|
| 1035 |
|
|
NTFS_PUTU16(buf + 0x14, hdrsize);
|
| 1036 |
|
|
if (attr->size)
|
| 1037 |
|
|
ntfs_memcpy(buf + hdrsize, attr->d.data, attr->size);
|
| 1038 |
|
|
} else {
|
| 1039 |
|
|
int error;
|
| 1040 |
|
|
|
| 1041 |
|
|
if (attr->flags & ATTR_IS_COMPRESSED)
|
| 1042 |
|
|
nameoff = 0x48;
|
| 1043 |
|
|
else
|
| 1044 |
|
|
nameoff = 0x40;
|
| 1045 |
|
|
hdrsize = (nameoff + 2 * attr->namelen + 7) & ~7;
|
| 1046 |
|
|
if (size < hdrsize)
|
| 1047 |
|
|
return -E2BIG;
|
| 1048 |
|
|
/* Make asize point at the end of the attribute record header,
|
| 1049 |
|
|
i.e. at the beginning of the mapping pairs array. */
|
| 1050 |
|
|
asize = hdrsize;
|
| 1051 |
|
|
error = layout_runs(attr, buf, &asize, size);
|
| 1052 |
|
|
/* Now, asize points one byte beyond the end of the mapping
|
| 1053 |
|
|
pairs array. */
|
| 1054 |
|
|
if (error)
|
| 1055 |
|
|
return error;
|
| 1056 |
|
|
/* The next attribute has to begin on 8-byte boundary. */
|
| 1057 |
|
|
asize = (asize + 7) & ~7;
|
| 1058 |
|
|
/* FIXME: fragments */
|
| 1059 |
|
|
count_runs(attr, buf);
|
| 1060 |
|
|
NTFS_PUTU16(buf + 0x20, hdrsize);
|
| 1061 |
|
|
NTFS_PUTU16(buf + 0x22, attr->cengine);
|
| 1062 |
|
|
NTFS_PUTU32(buf + 0x24, 0);
|
| 1063 |
|
|
NTFS_PUTS64(buf + 0x28, attr->allocated);
|
| 1064 |
|
|
NTFS_PUTS64(buf + 0x30, attr->size);
|
| 1065 |
|
|
NTFS_PUTS64(buf + 0x38, attr->initialized);
|
| 1066 |
|
|
if (attr->flags & ATTR_IS_COMPRESSED)
|
| 1067 |
|
|
NTFS_PUTS64(buf + 0x40, attr->compsize);
|
| 1068 |
|
|
}
|
| 1069 |
|
|
NTFS_PUTU32(buf, attr->type);
|
| 1070 |
|
|
NTFS_PUTU32(buf + 4, asize);
|
| 1071 |
|
|
NTFS_PUTU8(buf + 8, attr->resident ? 0 : 1);
|
| 1072 |
|
|
NTFS_PUTU8(buf + 9, attr->namelen);
|
| 1073 |
|
|
NTFS_PUTU16(buf + 0xa, nameoff);
|
| 1074 |
|
|
NTFS_PUTU16(buf + 0xc, attr->flags);
|
| 1075 |
|
|
NTFS_PUTU16(buf + 0xe, attr->attrno);
|
| 1076 |
|
|
if (attr->namelen)
|
| 1077 |
|
|
ntfs_memcpy(buf + nameoff, attr->name, 2 * attr->namelen);
|
| 1078 |
|
|
*psize = asize;
|
| 1079 |
|
|
return 0;
|
| 1080 |
|
|
}
|
| 1081 |
|
|
|
| 1082 |
|
|
/**
|
| 1083 |
|
|
* layout_inode - convert an in-memory inode into on disk mft record(s)
|
| 1084 |
|
|
* @ino: in memory inode to convert
|
| 1085 |
|
|
* @store: on disk inode, contain buffers for the on disk mft record(s)
|
| 1086 |
|
|
*
|
| 1087 |
|
|
* layout_inode takes the in memory inode @ino, converts it into a (sequence of)
|
| 1088 |
|
|
* mft record(s) and writes them to the appropriate buffers in the @store.
|
| 1089 |
|
|
*
|
| 1090 |
|
|
* Return 0 on success,
|
| 1091 |
|
|
* the required mft record count (>0) if the inode does not fit,
|
| 1092 |
|
|
* -ENOMEM if memory allocation problem, or
|
| 1093 |
|
|
* -EOPNOTSUP if beyond our capabilities.
|
| 1094 |
|
|
*
|
| 1095 |
|
|
* TODO: We at the moment do not support extension mft records. (AIA)
|
| 1096 |
|
|
*/
|
| 1097 |
|
|
int layout_inode(ntfs_inode *ino, ntfs_disk_inode *store)
|
| 1098 |
|
|
{
|
| 1099 |
|
|
int offset, i, size, psize, error, count, recno;
|
| 1100 |
|
|
ntfs_attribute *attr;
|
| 1101 |
|
|
unsigned char *rec;
|
| 1102 |
|
|
|
| 1103 |
|
|
error = allocate_store(ino->vol, store, ino->record_count);
|
| 1104 |
|
|
if (error)
|
| 1105 |
|
|
return error;
|
| 1106 |
|
|
size = ino->vol->mft_record_size;
|
| 1107 |
|
|
count = i = 0;
|
| 1108 |
|
|
do {
|
| 1109 |
|
|
if (count < ino->record_count) {
|
| 1110 |
|
|
recno = ino->records[count];
|
| 1111 |
|
|
} else {
|
| 1112 |
|
|
error = allocate_store(ino->vol, store, count + 1);
|
| 1113 |
|
|
if (error)
|
| 1114 |
|
|
return error;
|
| 1115 |
|
|
recno = -1;
|
| 1116 |
|
|
}
|
| 1117 |
|
|
/*
|
| 1118 |
|
|
* FIXME: We need to support extension records properly.
|
| 1119 |
|
|
* At the moment they wouldn't work. Probably would "just" get
|
| 1120 |
|
|
* corrupted if we write to them... (AIA)
|
| 1121 |
|
|
*/
|
| 1122 |
|
|
store->records[count].recno = recno;
|
| 1123 |
|
|
rec = store->records[count].record;
|
| 1124 |
|
|
count++;
|
| 1125 |
|
|
/* Copy mft record header. */
|
| 1126 |
|
|
offset = NTFS_GETU16(ino->attr + 0x14); /* attrs_offset */
|
| 1127 |
|
|
ntfs_memcpy(rec, ino->attr, offset);
|
| 1128 |
|
|
/* Copy attributes. */
|
| 1129 |
|
|
while (i < ino->attr_count) {
|
| 1130 |
|
|
attr = ino->attrs + i;
|
| 1131 |
|
|
error = layout_attr(attr, rec + offset,
|
| 1132 |
|
|
size - offset - 8, &psize);
|
| 1133 |
|
|
if (error == -E2BIG && offset != NTFS_GETU16(ino->attr
|
| 1134 |
|
|
+ 0x14))
|
| 1135 |
|
|
break;
|
| 1136 |
|
|
if (error)
|
| 1137 |
|
|
return error;
|
| 1138 |
|
|
offset += psize;
|
| 1139 |
|
|
i++;
|
| 1140 |
|
|
}
|
| 1141 |
|
|
/* Terminating attribute. */
|
| 1142 |
|
|
NTFS_PUTU32(rec + offset, 0xFFFFFFFF);
|
| 1143 |
|
|
offset += 4;
|
| 1144 |
|
|
NTFS_PUTU32(rec + offset, 0);
|
| 1145 |
|
|
offset += 4;
|
| 1146 |
|
|
NTFS_PUTU32(rec + 0x18, offset);
|
| 1147 |
|
|
} while (i < ino->attr_count || count < ino->record_count);
|
| 1148 |
|
|
return count - ino->record_count;
|
| 1149 |
|
|
}
|
| 1150 |
|
|
|
| 1151 |
|
|
/*
|
| 1152 |
|
|
* FIXME: ntfs_update_inode() calls layout_inode() to create the mft record on
|
| 1153 |
|
|
* disk structure corresponding to the inode @ino. After that, ntfs_write_attr()
|
| 1154 |
|
|
* is called to write out the created mft record to disk.
|
| 1155 |
|
|
* We shouldn't need to re-layout every single time we are updating an mft
|
| 1156 |
|
|
* record. No wonder the ntfs driver is slow like hell. (AIA)
|
| 1157 |
|
|
*/
|
| 1158 |
|
|
int ntfs_update_inode(ntfs_inode *ino)
|
| 1159 |
|
|
{
|
| 1160 |
|
|
int error, i;
|
| 1161 |
|
|
ntfs_disk_inode store;
|
| 1162 |
|
|
ntfs_io io;
|
| 1163 |
|
|
|
| 1164 |
|
|
ntfs_bzero(&store, sizeof(store));
|
| 1165 |
|
|
error = layout_inode(ino, &store);
|
| 1166 |
|
|
if (error == -E2BIG) {
|
| 1167 |
|
|
i = ntfs_split_indexroot(ino);
|
| 1168 |
|
|
if (i != -ENOTDIR) {
|
| 1169 |
|
|
if (!i)
|
| 1170 |
|
|
i = layout_inode(ino, &store);
|
| 1171 |
|
|
error = i;
|
| 1172 |
|
|
}
|
| 1173 |
|
|
}
|
| 1174 |
|
|
if (error == -E2BIG) {
|
| 1175 |
|
|
error = ntfs_attr_allnonresident(ino);
|
| 1176 |
|
|
if (!error)
|
| 1177 |
|
|
error = layout_inode(ino, &store);
|
| 1178 |
|
|
}
|
| 1179 |
|
|
if (error > 0) {
|
| 1180 |
|
|
/* FIXME: Introduce extension records. */
|
| 1181 |
|
|
error = -E2BIG;
|
| 1182 |
|
|
}
|
| 1183 |
|
|
if (error) {
|
| 1184 |
|
|
if (error == -E2BIG)
|
| 1185 |
|
|
ntfs_error("Cannot handle saving inode 0x%x.\n",
|
| 1186 |
|
|
ino->i_number);
|
| 1187 |
|
|
deallocate_store(&store);
|
| 1188 |
|
|
return error;
|
| 1189 |
|
|
}
|
| 1190 |
|
|
io.fn_get = ntfs_get;
|
| 1191 |
|
|
io.fn_put = 0;
|
| 1192 |
|
|
for (i = 0; i < store.count; i++) {
|
| 1193 |
|
|
error = ntfs_insert_fixups(store.records[i].record,
|
| 1194 |
|
|
ino->vol->mft_record_size);
|
| 1195 |
|
|
if (error) {
|
| 1196 |
|
|
printk(KERN_ALERT "NTFS: ntfs_update_inode() caught "
|
| 1197 |
|
|
"corrupt %s mtf record ntfs record "
|
| 1198 |
|
|
"header. Refusing to write corrupt "
|
| 1199 |
|
|
"data to disk. Unmount and run chkdsk "
|
| 1200 |
|
|
"immediately!\n", i ? "extension":
|
| 1201 |
|
|
"base");
|
| 1202 |
|
|
deallocate_store(&store);
|
| 1203 |
|
|
return -EIO;
|
| 1204 |
|
|
}
|
| 1205 |
|
|
io.param = store.records[i].record;
|
| 1206 |
|
|
io.size = ino->vol->mft_record_size;
|
| 1207 |
|
|
error = ntfs_write_attr(ino->vol->mft_ino, ino->vol->at_data,
|
| 1208 |
|
|
0, (__s64)store.records[i].recno <<
|
| 1209 |
|
|
ino->vol->mft_record_size_bits, &io);
|
| 1210 |
|
|
if (error || io.size != ino->vol->mft_record_size) {
|
| 1211 |
|
|
/* Big trouble, partially written file. */
|
| 1212 |
|
|
ntfs_error("Please unmount: Write error in inode "
|
| 1213 |
|
|
"0x%x\n", ino->i_number);
|
| 1214 |
|
|
deallocate_store(&store);
|
| 1215 |
|
|
return error ? error : -EIO;
|
| 1216 |
|
|
}
|
| 1217 |
|
|
}
|
| 1218 |
|
|
deallocate_store(&store);
|
| 1219 |
|
|
return 0;
|
| 1220 |
|
|
}
|
| 1221 |
|
|
|
| 1222 |
|
|
void ntfs_decompress(unsigned char *dest, unsigned char *src, ntfs_size_t l)
|
| 1223 |
|
|
{
|
| 1224 |
|
|
int head, comp;
|
| 1225 |
|
|
int copied = 0;
|
| 1226 |
|
|
unsigned char *stop;
|
| 1227 |
|
|
int bits;
|
| 1228 |
|
|
int tag = 0;
|
| 1229 |
|
|
int clear_pos;
|
| 1230 |
|
|
|
| 1231 |
|
|
while (1) {
|
| 1232 |
|
|
head = NTFS_GETU16(src) & 0xFFF;
|
| 1233 |
|
|
/* High bit indicates that compression was performed. */
|
| 1234 |
|
|
comp = NTFS_GETU16(src) & 0x8000;
|
| 1235 |
|
|
src += 2;
|
| 1236 |
|
|
stop = src + head;
|
| 1237 |
|
|
bits = 0;
|
| 1238 |
|
|
clear_pos = 0;
|
| 1239 |
|
|
if (head == 0)
|
| 1240 |
|
|
/* Block is not used. */
|
| 1241 |
|
|
return;/* FIXME: copied */
|
| 1242 |
|
|
if (!comp) { /* uncompressible */
|
| 1243 |
|
|
ntfs_memcpy(dest, src, 0x1000);
|
| 1244 |
|
|
dest += 0x1000;
|
| 1245 |
|
|
copied += 0x1000;
|
| 1246 |
|
|
src += 0x1000;
|
| 1247 |
|
|
if (l == copied)
|
| 1248 |
|
|
return;
|
| 1249 |
|
|
continue;
|
| 1250 |
|
|
}
|
| 1251 |
|
|
while (src <= stop) {
|
| 1252 |
|
|
if (clear_pos > 4096) {
|
| 1253 |
|
|
ntfs_error("Error 1 in decompress\n");
|
| 1254 |
|
|
return;
|
| 1255 |
|
|
}
|
| 1256 |
|
|
if (!bits) {
|
| 1257 |
|
|
tag = NTFS_GETU8(src);
|
| 1258 |
|
|
bits = 8;
|
| 1259 |
|
|
src++;
|
| 1260 |
|
|
if (src > stop)
|
| 1261 |
|
|
break;
|
| 1262 |
|
|
}
|
| 1263 |
|
|
if (tag & 1) {
|
| 1264 |
|
|
int i, len, delta, code, lmask, dshift;
|
| 1265 |
|
|
code = NTFS_GETU16(src);
|
| 1266 |
|
|
src += 2;
|
| 1267 |
|
|
if (!clear_pos) {
|
| 1268 |
|
|
ntfs_error("Error 2 in decompress\n");
|
| 1269 |
|
|
return;
|
| 1270 |
|
|
}
|
| 1271 |
|
|
for (i = clear_pos - 1, lmask = 0xFFF,
|
| 1272 |
|
|
dshift = 12; i >= 0x10; i >>= 1) {
|
| 1273 |
|
|
lmask >>= 1;
|
| 1274 |
|
|
dshift--;
|
| 1275 |
|
|
}
|
| 1276 |
|
|
delta = code >> dshift;
|
| 1277 |
|
|
len = (code & lmask) + 3;
|
| 1278 |
|
|
for (i = 0; i < len; i++) {
|
| 1279 |
|
|
dest[clear_pos] = dest[clear_pos -
|
| 1280 |
|
|
delta - 1];
|
| 1281 |
|
|
clear_pos++;
|
| 1282 |
|
|
copied++;
|
| 1283 |
|
|
if (copied==l)
|
| 1284 |
|
|
return;
|
| 1285 |
|
|
}
|
| 1286 |
|
|
} else {
|
| 1287 |
|
|
dest[clear_pos++] = NTFS_GETU8(src);
|
| 1288 |
|
|
src++;
|
| 1289 |
|
|
copied++;
|
| 1290 |
|
|
if (copied==l)
|
| 1291 |
|
|
return;
|
| 1292 |
|
|
}
|
| 1293 |
|
|
tag >>= 1;
|
| 1294 |
|
|
bits--;
|
| 1295 |
|
|
}
|
| 1296 |
|
|
dest += clear_pos;
|
| 1297 |
|
|
}
|
| 1298 |
|
|
}
|
| 1299 |
|
|
|
| 1300 |
|
|
/*
|
| 1301 |
|
|
* NOTE: Neither of the ntfs_*_bit functions are atomic! But we don't need
|
| 1302 |
|
|
* them atomic at present as we never operate on shared/cached bitmaps.
|
| 1303 |
|
|
*/
|
| 1304 |
|
|
static __inline__ int ntfs_test_bit(unsigned char *byte, const int bit)
|
| 1305 |
|
|
{
|
| 1306 |
|
|
return byte[bit >> 3] & (1 << (bit & 7)) ? 1 : 0;
|
| 1307 |
|
|
}
|
| 1308 |
|
|
|
| 1309 |
|
|
static __inline__ void ntfs_set_bit(unsigned char *byte, const int bit)
|
| 1310 |
|
|
{
|
| 1311 |
|
|
byte[bit >> 3] |= 1 << (bit & 7);
|
| 1312 |
|
|
}
|
| 1313 |
|
|
|
| 1314 |
|
|
static __inline__ void ntfs_clear_bit(unsigned char *byte, const int bit)
|
| 1315 |
|
|
{
|
| 1316 |
|
|
byte[bit >> 3] &= ~(1 << (bit & 7));
|
| 1317 |
|
|
}
|
| 1318 |
|
|
|
| 1319 |
|
|
static __inline__ int ntfs_test_and_clear_bit(unsigned char *byte,
|
| 1320 |
|
|
const int bit)
|
| 1321 |
|
|
{
|
| 1322 |
|
|
unsigned char *ptr = byte + (bit >> 3);
|
| 1323 |
|
|
int b = 1 << (bit & 7);
|
| 1324 |
|
|
int oldbit = *ptr & b ? 1 : 0;
|
| 1325 |
|
|
*ptr &= ~b;
|
| 1326 |
|
|
return oldbit;
|
| 1327 |
|
|
}
|
| 1328 |
|
|
|
| 1329 |
|
|
static void dump_runlist(const ntfs_runlist *rl, const int rlen)
|
| 1330 |
|
|
{
|
| 1331 |
|
|
#ifdef DEBUG
|
| 1332 |
|
|
int i;
|
| 1333 |
|
|
ntfs_cluster_t ct;
|
| 1334 |
|
|
|
| 1335 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): rlen = %i.\n", __FUNCTION__, rlen);
|
| 1336 |
|
|
ntfs_debug(DEBUG_OTHER, "VCN LCN Run length\n");
|
| 1337 |
|
|
for (i = 0, ct = 0; i < rlen; ct += rl[i++].len) {
|
| 1338 |
|
|
if (rl[i].lcn == (ntfs_cluster_t)-1)
|
| 1339 |
|
|
ntfs_debug(DEBUG_OTHER, "0x%-8x LCN_HOLE 0x%-8x "
|
| 1340 |
|
|
"(%s)\n", ct, rl[i].len, rl[i].len ?
|
| 1341 |
|
|
"sparse run" : "run list end");
|
| 1342 |
|
|
else
|
| 1343 |
|
|
ntfs_debug(DEBUG_OTHER, "0x%-8x 0x%-8x 0x%-8x%s\n", ct,
|
| 1344 |
|
|
rl[i].lcn, rl[i].len, rl[i].len &&
|
| 1345 |
|
|
i + 1 < rlen ? "" : " (run list end)");
|
| 1346 |
|
|
if (!rl[i].len)
|
| 1347 |
|
|
break;
|
| 1348 |
|
|
}
|
| 1349 |
|
|
#endif
|
| 1350 |
|
|
}
|
| 1351 |
|
|
|
| 1352 |
|
|
/**
|
| 1353 |
|
|
* splice_runlists - splice two run lists into one
|
| 1354 |
|
|
* @rl1: pointer to address of first run list
|
| 1355 |
|
|
* @r1len: number of elementfs in first run list
|
| 1356 |
|
|
* @rl2: pointer to second run list
|
| 1357 |
|
|
* @r2len: number of elements in second run list
|
| 1358 |
|
|
*
|
| 1359 |
|
|
* Append the run list @rl2 to the run list *@rl1 and return the result in
|
| 1360 |
|
|
* *@rl1 and *@r1len.
|
| 1361 |
|
|
*
|
| 1362 |
|
|
* Return 0 on success or -errno on error, in which case *@rl1 and *@r1len are
|
| 1363 |
|
|
* left untouched.
|
| 1364 |
|
|
*
|
| 1365 |
|
|
* The only possible error code at the moment is -ENOMEM and only happens if
|
| 1366 |
|
|
* there is insufficient memory to allocate the new run list (only happens
|
| 1367 |
|
|
* when size of (rl1 + rl2) > allocated size of rl1).
|
| 1368 |
|
|
*/
|
| 1369 |
|
|
int splice_runlists(ntfs_runlist **rl1, int *r1len, const ntfs_runlist *rl2,
|
| 1370 |
|
|
int r2len)
|
| 1371 |
|
|
{
|
| 1372 |
|
|
ntfs_runlist *rl;
|
| 1373 |
|
|
int rlen, rl_size, rl2_pos;
|
| 1374 |
|
|
|
| 1375 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Entering with *r1len = %i, "
|
| 1376 |
|
|
"r2len = %i.\n", __FUNCTION__, *r1len, r2len);
|
| 1377 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Dumping 1st runlist.\n", __FUNCTION__);
|
| 1378 |
|
|
if (*rl1)
|
| 1379 |
|
|
dump_runlist(*rl1, *r1len);
|
| 1380 |
|
|
else
|
| 1381 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Not present.\n", __FUNCTION__);
|
| 1382 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Dumping 2nd runlist.\n", __FUNCTION__);
|
| 1383 |
|
|
dump_runlist(rl2, r2len);
|
| 1384 |
|
|
rlen = *r1len + r2len + 1;
|
| 1385 |
|
|
rl_size = (rlen * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
|
| 1386 |
|
|
PAGE_MASK;
|
| 1387 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): rlen = %i, rl_size = %i.\n",
|
| 1388 |
|
|
__FUNCTION__, rlen, rl_size);
|
| 1389 |
|
|
/* Do we have enough space? */
|
| 1390 |
|
|
if (rl_size <= ((*r1len * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
|
| 1391 |
|
|
PAGE_MASK)) {
|
| 1392 |
|
|
/* Have enough space already. */
|
| 1393 |
|
|
rl = *rl1;
|
| 1394 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Have enough space already.\n",
|
| 1395 |
|
|
__FUNCTION__);
|
| 1396 |
|
|
} else {
|
| 1397 |
|
|
/* Need more space. Reallocate. */
|
| 1398 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Need more space.\n",
|
| 1399 |
|
|
__FUNCTION__);
|
| 1400 |
|
|
rl = ntfs_vmalloc(rlen << sizeof(ntfs_runlist));
|
| 1401 |
|
|
if (!rl)
|
| 1402 |
|
|
return -ENOMEM;
|
| 1403 |
|
|
/* Copy over rl1. */
|
| 1404 |
|
|
ntfs_memcpy(rl, *rl1, *r1len * sizeof(ntfs_runlist));
|
| 1405 |
|
|
ntfs_vfree(*rl1);
|
| 1406 |
|
|
*rl1 = rl;
|
| 1407 |
|
|
}
|
| 1408 |
|
|
/* Reuse rl_size as the current position index into rl. */
|
| 1409 |
|
|
rl_size = *r1len - 1;
|
| 1410 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): rl_size = %i.\n", __FUNCTION__,rl_size);
|
| 1411 |
|
|
/* Coalesce neighbouring elements, if present. */
|
| 1412 |
|
|
rl2_pos = 0;
|
| 1413 |
|
|
if (rl[rl_size].lcn + rl[rl_size].len == rl2[rl2_pos].lcn) {
|
| 1414 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Coalescing adjacent runs.\n",
|
| 1415 |
|
|
__FUNCTION__);
|
| 1416 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Before: rl[rl_size].len = %i.\n",
|
| 1417 |
|
|
__FUNCTION__, rl[rl_size].len);
|
| 1418 |
|
|
rl[rl_size].len += rl2[rl2_pos].len;
|
| 1419 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After: rl[rl_size].len = %i.\n",
|
| 1420 |
|
|
__FUNCTION__, rl[rl_size].len);
|
| 1421 |
|
|
rl2_pos++;
|
| 1422 |
|
|
r2len--;
|
| 1423 |
|
|
rlen--;
|
| 1424 |
|
|
}
|
| 1425 |
|
|
rl_size++;
|
| 1426 |
|
|
/* Copy over rl2. */
|
| 1427 |
|
|
ntfs_memcpy(rl + rl_size, rl2 + rl2_pos, r2len * sizeof(ntfs_runlist));
|
| 1428 |
|
|
rlen--;
|
| 1429 |
|
|
rl[rlen].lcn = (ntfs_cluster_t)-1;
|
| 1430 |
|
|
rl[rlen].len = (ntfs_cluster_t)0;
|
| 1431 |
|
|
*r1len = rlen;
|
| 1432 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Dumping result runlist.\n",
|
| 1433 |
|
|
__FUNCTION__);
|
| 1434 |
|
|
dump_runlist(*rl1, *r1len);
|
| 1435 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Returning with *r1len = %i.\n",
|
| 1436 |
|
|
__FUNCTION__, rlen);
|
| 1437 |
|
|
return 0;
|
| 1438 |
|
|
}
|
| 1439 |
|
|
|
| 1440 |
|
|
/**
|
| 1441 |
|
|
* ntfs_alloc_mft_record - allocate an mft record
|
| 1442 |
|
|
* @vol: volume to allocate an mft record on
|
| 1443 |
|
|
* @result: the mft record number allocated
|
| 1444 |
|
|
*
|
| 1445 |
|
|
* Allocate a new mft record on disk. Return 0 on success or -ERRNO on error.
|
| 1446 |
|
|
* On success, *@result contains the allocated mft record number. On error,
|
| 1447 |
|
|
* *@result is -1UL.
|
| 1448 |
|
|
*
|
| 1449 |
|
|
* Note, this function doesn't actually set the mft record to be in use. This
|
| 1450 |
|
|
* is done by the caller, which at the moment is only ntfs_alloc_inode().
|
| 1451 |
|
|
*
|
| 1452 |
|
|
* To find a free mft record, we scan the mft bitmap for a zero bit. To
|
| 1453 |
|
|
* optimize this we start scanning at the place where we last stopped and we
|
| 1454 |
|
|
* perform wrap around when we reach the end. Note, we do not try to allocate
|
| 1455 |
|
|
* mft records below number 24 because numbers 0 to 15 are the defined system
|
| 1456 |
|
|
* files anyway and 16 to 24 are special in that they are used for storing
|
| 1457 |
|
|
* extension mft records for $MFT's $DATA attribute. This is required to avoid
|
| 1458 |
|
|
* the possibility of creating a run list with a circular dependence which once
|
| 1459 |
|
|
* written to disk can never be read in again. Windows will only use records
|
| 1460 |
|
|
* 16 to 24 for normal files if the volume is completely out of space. We never
|
| 1461 |
|
|
* use them which means that when the volume is really out of space we cannot
|
| 1462 |
|
|
* create any more files while Windows can still create up to 8 small files. We
|
| 1463 |
|
|
* can start doing this at some later time, doesn't matter much for now.
|
| 1464 |
|
|
*
|
| 1465 |
|
|
* When scanning the mft bitmap, we only search up to the last allocated mft
|
| 1466 |
|
|
* record. If there are no free records left in the range 24 to number of
|
| 1467 |
|
|
* allocated mft records, then we extend the mft data in order to create free
|
| 1468 |
|
|
* mft records. We extend the allocated size of $MFT/$DATA by 16 records at a
|
| 1469 |
|
|
* time or one cluster, if cluster size is above 16kiB. If there isn't
|
| 1470 |
|
|
* sufficient space to do this, we try to extend by a single mft record or one
|
| 1471 |
|
|
* cluster, if cluster size is above mft record size, but we only do this if
|
| 1472 |
|
|
* there is enough free space, which we know from the values returned by the
|
| 1473 |
|
|
* failed cluster allocation function when we tried to do the first allocation.
|
| 1474 |
|
|
*
|
| 1475 |
|
|
* No matter how many mft records we allocate, we initialize only the first
|
| 1476 |
|
|
* allocated mft record (incrementing mft data size and initialized size) and
|
| 1477 |
|
|
* return its number to the caller in @*result, unless there are less than 24
|
| 1478 |
|
|
* mft records, in which case we allocate and initialize mft records until we
|
| 1479 |
|
|
* reach record 24 which we consider as the first free mft record for use by
|
| 1480 |
|
|
* normal files.
|
| 1481 |
|
|
*
|
| 1482 |
|
|
* If during any stage we overflow the initialized data in the mft bitmap, we
|
| 1483 |
|
|
* extend the initialized size (and data size) by 8 bytes, allocating another
|
| 1484 |
|
|
* cluster if required. The bitmap data size has to be at least equal to the
|
| 1485 |
|
|
* number of mft records in the mft, but it can be bigger, in which case the
|
| 1486 |
|
|
* superflous bits are padded with zeroes.
|
| 1487 |
|
|
*
|
| 1488 |
|
|
* Thus, when we return successfully (return value 0), we will have:
|
| 1489 |
|
|
* - initialized / extended the mft bitmap if necessary,
|
| 1490 |
|
|
* - initialized / extended the mft data if necessary,
|
| 1491 |
|
|
* - set the bit corresponding to the mft record being allocated in the
|
| 1492 |
|
|
* mft bitmap, and we will
|
| 1493 |
|
|
* - return the mft record number in @*result.
|
| 1494 |
|
|
*
|
| 1495 |
|
|
* On error (return value below zero), nothing will have changed. If we had
|
| 1496 |
|
|
* changed anything before the error occured, we will have reverted back to
|
| 1497 |
|
|
* the starting state before returning to the caller. Thus, except for bugs,
|
| 1498 |
|
|
* we should always leave the volume in a consitents state when returning from
|
| 1499 |
|
|
* this function. NOTE: Small exception to this is that we set the bit in the
|
| 1500 |
|
|
* mft bitmap but we do not mark the mft record in use, which is inconsistent.
|
| 1501 |
|
|
* However, the caller will immediately add the wanted attributes to the mft
|
| 1502 |
|
|
* record, set it in use and write it out to disk, so there should be no
|
| 1503 |
|
|
* problem.
|
| 1504 |
|
|
*
|
| 1505 |
|
|
* Note, this function cannot make use of most of the normal functions, like
|
| 1506 |
|
|
* for example for attribute resizing, etc, because when the run list overflows
|
| 1507 |
|
|
* the base mft record and an attribute list is used, it is very important
|
| 1508 |
|
|
* that the extension mft records used to store the $DATA attribute of $MFT
|
| 1509 |
|
|
* can be reached without having to read the information contained inside
|
| 1510 |
|
|
* them, as this would make it impossible to find them in the first place
|
| 1511 |
|
|
* after the volume is dismounted. $MFT/$BITMAP probably doesn't need to
|
| 1512 |
|
|
* follow this rule because the bitmap is not essential for finding the mft
|
| 1513 |
|
|
* records, but on the other hand, handling the bitmap in this special way
|
| 1514 |
|
|
* would make life easier because otherwise there might be circular invocations
|
| 1515 |
|
|
* of functions when reading the bitmap but if we are careful, we should be
|
| 1516 |
|
|
* able to avoid all problems.
|
| 1517 |
|
|
*
|
| 1518 |
|
|
* FIXME: Don't forget $MftMirr, though this probably belongs in
|
| 1519 |
|
|
* ntfs_update_inode() (or even deeper). (AIA)
|
| 1520 |
|
|
*
|
| 1521 |
|
|
* FIXME: Want finer grained locking. (AIA)
|
| 1522 |
|
|
*/
|
| 1523 |
|
|
static int ntfs_alloc_mft_record(ntfs_volume *vol, unsigned long *result)
|
| 1524 |
|
|
{
|
| 1525 |
|
|
unsigned long nr_mft_records, buf_size, buf_pos, pass_start, pass_end;
|
| 1526 |
|
|
unsigned long last_read_pos, mft_rec_size, bit, l;
|
| 1527 |
|
|
ntfs_attribute *data, *bmp;
|
| 1528 |
|
|
__u8 *buf, *byte, pass, b, have_allocated_mftbmp = 0;
|
| 1529 |
|
|
int rlen, rl_size = 0, r2len, rl2_size, old_data_rlen, err = 0;
|
| 1530 |
|
|
ntfs_runlist *rl, *rl2;
|
| 1531 |
|
|
ntfs_cluster_t lcn = 0, old_data_len;
|
| 1532 |
|
|
ntfs_io io;
|
| 1533 |
|
|
__s64 ll, old_data_allocated, old_data_initialized, old_data_size;
|
| 1534 |
|
|
|
| 1535 |
|
|
*result = -1UL;
|
| 1536 |
|
|
/* Allocate a buffer and setup the io structure. */
|
| 1537 |
|
|
buf = (__u8*)__get_free_page(GFP_NOFS);
|
| 1538 |
|
|
if (!buf)
|
| 1539 |
|
|
return -ENOMEM;
|
| 1540 |
|
|
lock_kernel();
|
| 1541 |
|
|
/* Get the $DATA and $BITMAP attributes of $MFT. */
|
| 1542 |
|
|
data = ntfs_find_attr(vol->mft_ino, vol->at_data, 0);
|
| 1543 |
|
|
bmp = ntfs_find_attr(vol->mft_ino, vol->at_bitmap, 0);
|
| 1544 |
|
|
if (!data || !bmp) {
|
| 1545 |
|
|
err = -EINVAL;
|
| 1546 |
|
|
goto err_ret;
|
| 1547 |
|
|
}
|
| 1548 |
|
|
/* Determine the number of allocated mft records in the mft. */
|
| 1549 |
|
|
pass_end = nr_mft_records = data->allocated >>
|
| 1550 |
|
|
vol->mft_record_size_bits;
|
| 1551 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): nr_mft_records = %lu.\n", __FUNCTION__,
|
| 1552 |
|
|
nr_mft_records);
|
| 1553 |
|
|
/* Make sure we don't overflow the bitmap. */
|
| 1554 |
|
|
l = bmp->initialized << 3;
|
| 1555 |
|
|
if (l < nr_mft_records)
|
| 1556 |
|
|
// FIXME: It might be a good idea to extend the bitmap instead.
|
| 1557 |
|
|
pass_end = l;
|
| 1558 |
|
|
pass = 1;
|
| 1559 |
|
|
buf_pos = vol->mft_data_pos;
|
| 1560 |
|
|
if (buf_pos >= pass_end) {
|
| 1561 |
|
|
buf_pos = 24UL;
|
| 1562 |
|
|
pass = 2;
|
| 1563 |
|
|
}
|
| 1564 |
|
|
pass_start = buf_pos;
|
| 1565 |
|
|
rl = bmp->d.r.runlist;
|
| 1566 |
|
|
rlen = bmp->d.r.len - 1;
|
| 1567 |
|
|
lcn = rl[rlen].lcn + rl[rlen].len;
|
| 1568 |
|
|
io.fn_put = ntfs_put;
|
| 1569 |
|
|
io.fn_get = ntfs_get;
|
| 1570 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Starting bitmap search.\n",
|
| 1571 |
|
|
__FUNCTION__);
|
| 1572 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): pass = %i, pass_start = %lu, pass_end = "
|
| 1573 |
|
|
"%lu.\n", __FUNCTION__, pass, pass_start, pass_end);
|
| 1574 |
|
|
byte = NULL; // FIXME: For debugging only.
|
| 1575 |
|
|
/* Loop until a free mft record is found. */
|
| 1576 |
|
|
io.size = (nr_mft_records >> 3) & ~PAGE_MASK;
|
| 1577 |
|
|
for (;; io.size = PAGE_SIZE) {
|
| 1578 |
|
|
io.param = buf;
|
| 1579 |
|
|
io.do_read = 1;
|
| 1580 |
|
|
last_read_pos = buf_pos >> 3;
|
| 1581 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Before: bmp->allocated = 0x%Lx, "
|
| 1582 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = "
|
| 1583 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1584 |
|
|
bmp->size, bmp->initialized);
|
| 1585 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, bmp, last_read_pos,
|
| 1586 |
|
|
&io);
|
| 1587 |
|
|
if (err)
|
| 1588 |
|
|
goto err_ret;
|
| 1589 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Read %lu bytes.\n", __FUNCTION__,
|
| 1590 |
|
|
(unsigned long)io.size);
|
| 1591 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After: bmp->allocated = 0x%Lx, "
|
| 1592 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = "
|
| 1593 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1594 |
|
|
bmp->size, bmp->initialized);
|
| 1595 |
|
|
if (!io.size)
|
| 1596 |
|
|
goto pass_done;
|
| 1597 |
|
|
buf_size = io.size << 3;
|
| 1598 |
|
|
bit = buf_pos & 7UL;
|
| 1599 |
|
|
buf_pos &= ~7UL;
|
| 1600 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Before loop: buf_size = %lu, "
|
| 1601 |
|
|
"buf_pos = %lu, bit = %lu, *byte = 0x%x, b = "
|
| 1602 |
|
|
"%u.\n", __FUNCTION__, buf_size, buf_pos, bit,
|
| 1603 |
|
|
byte ? *byte : -1, b);
|
| 1604 |
|
|
for (; bit < buf_size && bit + buf_pos < pass_end;
|
| 1605 |
|
|
bit &= ~7UL, bit += 8UL) {
|
| 1606 |
|
|
byte = buf + (bit >> 3);
|
| 1607 |
|
|
if (*byte == 0xff)
|
| 1608 |
|
|
continue;
|
| 1609 |
|
|
b = ffz((unsigned long)*byte);
|
| 1610 |
|
|
if (b < (__u8)8 && b >= (bit & 7UL)) {
|
| 1611 |
|
|
bit = b + (bit & ~7UL) + buf_pos;
|
| 1612 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Found free rec "
|
| 1613 |
|
|
"in for loop. bit = %lu\n",
|
| 1614 |
|
|
__FUNCTION__, bit);
|
| 1615 |
|
|
goto found_free_rec;
|
| 1616 |
|
|
}
|
| 1617 |
|
|
}
|
| 1618 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After loop: buf_size = %lu, "
|
| 1619 |
|
|
"buf_pos = %lu, bit = %lu, *byte = 0x%x, b = "
|
| 1620 |
|
|
"%u.\n", __FUNCTION__, buf_size, buf_pos, bit,
|
| 1621 |
|
|
byte ? *byte : -1, b);
|
| 1622 |
|
|
buf_pos += buf_size;
|
| 1623 |
|
|
if (buf_pos < pass_end)
|
| 1624 |
|
|
continue;
|
| 1625 |
|
|
pass_done: /* Finished with the current pass. */
|
| 1626 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At pass_done.\n", __FUNCTION__);
|
| 1627 |
|
|
if (pass == 1) {
|
| 1628 |
|
|
/*
|
| 1629 |
|
|
* Now do pass 2, scanning the first part of the zone
|
| 1630 |
|
|
* we omitted in pass 1.
|
| 1631 |
|
|
*/
|
| 1632 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Done pass 1.\n",
|
| 1633 |
|
|
__FUNCTION__);
|
| 1634 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Pass = 2.\n",
|
| 1635 |
|
|
__FUNCTION__);
|
| 1636 |
|
|
pass = 2;
|
| 1637 |
|
|
pass_end = pass_start;
|
| 1638 |
|
|
buf_pos = pass_start = 24UL;
|
| 1639 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): pass = %i, pass_start = "
|
| 1640 |
|
|
"%lu, pass_end = %lu.\n", __FUNCTION__,
|
| 1641 |
|
|
pass, pass_start, pass_end);
|
| 1642 |
|
|
continue;
|
| 1643 |
|
|
} /* pass == 2 */
|
| 1644 |
|
|
/* No free records left. */
|
| 1645 |
|
|
if (bmp->initialized << 3 > nr_mft_records &&
|
| 1646 |
|
|
bmp->initialized > 3) {
|
| 1647 |
|
|
/*
|
| 1648 |
|
|
* The mft bitmap is already bigger but the space is
|
| 1649 |
|
|
* not covered by mft records, this implies that the
|
| 1650 |
|
|
* next records are all free, so we already have found
|
| 1651 |
|
|
* a free record.
|
| 1652 |
|
|
*/
|
| 1653 |
|
|
bit = nr_mft_records;
|
| 1654 |
|
|
if (bit < 24UL)
|
| 1655 |
|
|
bit = 24UL;
|
| 1656 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Found free record bit "
|
| 1657 |
|
|
"(#1) = 0x%lx.\n", __FUNCTION__, bit);
|
| 1658 |
|
|
goto found_free_rec;
|
| 1659 |
|
|
}
|
| 1660 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Done pass 2.\n", __FUNCTION__);
|
| 1661 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Before: bmp->allocated = 0x%Lx, "
|
| 1662 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = "
|
| 1663 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1664 |
|
|
bmp->size, bmp->initialized);
|
| 1665 |
|
|
/* Need to extend the mft bitmap. */
|
| 1666 |
|
|
if (bmp->initialized + 8LL > bmp->allocated) {
|
| 1667 |
|
|
ntfs_io io2;
|
| 1668 |
|
|
|
| 1669 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Initialized "
|
| 1670 |
|
|
"> allocated.\n", __FUNCTION__);
|
| 1671 |
|
|
/* Need to extend bitmap by one more cluster. */
|
| 1672 |
|
|
rl = bmp->d.r.runlist;
|
| 1673 |
|
|
rlen = bmp->d.r.len - 1;
|
| 1674 |
|
|
lcn = rl[rlen].lcn + rl[rlen].len;
|
| 1675 |
|
|
io2.fn_put = ntfs_put;
|
| 1676 |
|
|
io2.fn_get = ntfs_get;
|
| 1677 |
|
|
io2.param = &b;
|
| 1678 |
|
|
io2.size = 1;
|
| 1679 |
|
|
io2.do_read = 1;
|
| 1680 |
|
|
err = ntfs_readwrite_attr(vol->bitmap, data, lcn >> 3,
|
| 1681 |
|
|
&io2);
|
| 1682 |
|
|
if (err)
|
| 1683 |
|
|
goto err_ret;
|
| 1684 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Read %lu bytes.\n",
|
| 1685 |
|
|
__FUNCTION__, (unsigned long)io2.size);
|
| 1686 |
|
|
if (io2.size == 1 && b != 0xff) {
|
| 1687 |
|
|
__u8 tb = 1 << (lcn & (ntfs_cluster_t)7);
|
| 1688 |
|
|
if (!(b & tb)) {
|
| 1689 |
|
|
/* Next cluster is free. Allocate it. */
|
| 1690 |
|
|
b |= tb;
|
| 1691 |
|
|
io2.param = &b;
|
| 1692 |
|
|
io2.do_read = 0;
|
| 1693 |
|
|
err = ntfs_readwrite_attr(vol->bitmap,
|
| 1694 |
|
|
data, lcn >> 3, &io2);
|
| 1695 |
|
|
if (err || io.size != 1) {
|
| 1696 |
|
|
if (!err)
|
| 1697 |
|
|
err = -EIO;
|
| 1698 |
|
|
goto err_ret;
|
| 1699 |
|
|
}
|
| 1700 |
|
|
append_mftbmp_simple: rl[rlen].len++;
|
| 1701 |
|
|
have_allocated_mftbmp |= 1;
|
| 1702 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): "
|
| 1703 |
|
|
"Appending one cluster "
|
| 1704 |
|
|
"to mftbmp.\n",
|
| 1705 |
|
|
__FUNCTION__);
|
| 1706 |
|
|
}
|
| 1707 |
|
|
}
|
| 1708 |
|
|
if (!have_allocated_mftbmp) {
|
| 1709 |
|
|
/* Allocate a cluster from the DATA_ZONE. */
|
| 1710 |
|
|
ntfs_cluster_t lcn2 = lcn;
|
| 1711 |
|
|
ntfs_cluster_t count = 1;
|
| 1712 |
|
|
err = ntfs_allocate_clusters(vol, &lcn2,
|
| 1713 |
|
|
&count, &rl2, &r2len,
|
| 1714 |
|
|
DATA_ZONE);
|
| 1715 |
|
|
if (err)
|
| 1716 |
|
|
goto err_ret;
|
| 1717 |
|
|
if (count != 1 || lcn2 <= 0) {
|
| 1718 |
|
|
if (count > 0) {
|
| 1719 |
|
|
rl2_dealloc_err_out: if (ntfs_deallocate_clusters(
|
| 1720 |
|
|
vol, rl2, r2len))
|
| 1721 |
|
|
ntfs_error("%s(): "
|
| 1722 |
|
|
"Cluster "
|
| 1723 |
|
|
"deallocation in error "
|
| 1724 |
|
|
"code path failed! You "
|
| 1725 |
|
|
"should run chkdsk.\n",
|
| 1726 |
|
|
__FUNCTION__);
|
| 1727 |
|
|
}
|
| 1728 |
|
|
ntfs_vfree(rl2);
|
| 1729 |
|
|
if (!err)
|
| 1730 |
|
|
err = -EINVAL;
|
| 1731 |
|
|
goto err_ret;
|
| 1732 |
|
|
}
|
| 1733 |
|
|
if (lcn2 == lcn) {
|
| 1734 |
|
|
ntfs_vfree(rl2);
|
| 1735 |
|
|
goto append_mftbmp_simple;
|
| 1736 |
|
|
}
|
| 1737 |
|
|
/* We need to append a new run. */
|
| 1738 |
|
|
rl_size = (rlen * sizeof(ntfs_runlist) +
|
| 1739 |
|
|
PAGE_SIZE - 1) & PAGE_MASK;
|
| 1740 |
|
|
/* Reallocate memory if necessary. */
|
| 1741 |
|
|
if ((rlen + 2) * sizeof(ntfs_runlist) >=
|
| 1742 |
|
|
rl_size) {
|
| 1743 |
|
|
ntfs_runlist *rlt;
|
| 1744 |
|
|
|
| 1745 |
|
|
rl_size += PAGE_SIZE;
|
| 1746 |
|
|
rlt = ntfs_vmalloc(rl_size);
|
| 1747 |
|
|
if (!rlt) {
|
| 1748 |
|
|
err = -ENOMEM;
|
| 1749 |
|
|
goto rl2_dealloc_err_out;
|
| 1750 |
|
|
}
|
| 1751 |
|
|
ntfs_memcpy(rlt, rl, rl_size -
|
| 1752 |
|
|
PAGE_SIZE);
|
| 1753 |
|
|
ntfs_vfree(rl);
|
| 1754 |
|
|
bmp->d.r.runlist = rl = rlt;
|
| 1755 |
|
|
}
|
| 1756 |
|
|
ntfs_vfree(rl2);
|
| 1757 |
|
|
rl[rlen].lcn = lcn = lcn2;
|
| 1758 |
|
|
rl[rlen].len = count;
|
| 1759 |
|
|
bmp->d.r.len = ++rlen;
|
| 1760 |
|
|
have_allocated_mftbmp |= 2;
|
| 1761 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Adding run to "
|
| 1762 |
|
|
"mftbmp. LCN = %i, len = %i\n",
|
| 1763 |
|
|
__FUNCTION__, lcn, count);
|
| 1764 |
|
|
}
|
| 1765 |
|
|
/*
|
| 1766 |
|
|
* We now have extended the mft bitmap allocated size
|
| 1767 |
|
|
* by one cluster. Reflect this in the attribute.
|
| 1768 |
|
|
*/
|
| 1769 |
|
|
bmp->allocated += (__s64)vol->cluster_size;
|
| 1770 |
|
|
}
|
| 1771 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After: bmp->allocated = 0x%Lx, "
|
| 1772 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = "
|
| 1773 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1774 |
|
|
bmp->size, bmp->initialized);
|
| 1775 |
|
|
/* We now have sufficient allocated space. */
|
| 1776 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Now have sufficient allocated "
|
| 1777 |
|
|
"space in mftbmp.\n", __FUNCTION__);
|
| 1778 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Before: bmp->allocated = 0x%Lx, "
|
| 1779 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = "
|
| 1780 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1781 |
|
|
bmp->size, bmp->initialized);
|
| 1782 |
|
|
buf_pos = bmp->initialized;
|
| 1783 |
|
|
bmp->initialized += 8LL;
|
| 1784 |
|
|
if (bmp->initialized > bmp->size)
|
| 1785 |
|
|
bmp->size = bmp->initialized;
|
| 1786 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After: bmp->allocated = 0x%Lx, "
|
| 1787 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = "
|
| 1788 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1789 |
|
|
bmp->size, bmp->initialized);
|
| 1790 |
|
|
have_allocated_mftbmp |= 4;
|
| 1791 |
|
|
/* Update the mft bitmap attribute value. */
|
| 1792 |
|
|
memset(buf, 0, 8);
|
| 1793 |
|
|
io.param = buf;
|
| 1794 |
|
|
io.size = 8;
|
| 1795 |
|
|
io.do_read = 0;
|
| 1796 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, bmp, buf_pos, &io);
|
| 1797 |
|
|
if (err || io.size != 8) {
|
| 1798 |
|
|
if (!err)
|
| 1799 |
|
|
err = -EIO;
|
| 1800 |
|
|
goto shrink_mftbmp_err_ret;
|
| 1801 |
|
|
}
|
| 1802 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Wrote extended mftbmp bytes "
|
| 1803 |
|
|
"%lu.\n", __FUNCTION__, (unsigned long)io.size);
|
| 1804 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After write: bmp->allocated = "
|
| 1805 |
|
|
"0x%Lx, bmp->size = 0x%Lx, bmp->initialized = "
|
| 1806 |
|
|
"0x%Lx.\n", __FUNCTION__, bmp->allocated,
|
| 1807 |
|
|
bmp->size, bmp->initialized);
|
| 1808 |
|
|
bit = buf_pos << 3;
|
| 1809 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Found free record bit (#2) = "
|
| 1810 |
|
|
"0x%lx.\n", __FUNCTION__, bit);
|
| 1811 |
|
|
goto found_free_rec;
|
| 1812 |
|
|
}
|
| 1813 |
|
|
found_free_rec:
|
| 1814 |
|
|
/* bit is the found free mft record. Allocate it in the mft bitmap. */
|
| 1815 |
|
|
vol->mft_data_pos = bit;
|
| 1816 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At found_free_rec.\n", __FUNCTION__);
|
| 1817 |
|
|
io.param = buf;
|
| 1818 |
|
|
io.size = 1;
|
| 1819 |
|
|
io.do_read = 1;
|
| 1820 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Before update: bmp->allocated = 0x%Lx, "
|
| 1821 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = 0x%Lx.\n",
|
| 1822 |
|
|
__FUNCTION__, bmp->allocated,
|
| 1823 |
|
|
bmp->size, bmp->initialized);
|
| 1824 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
|
| 1825 |
|
|
if (err || io.size != 1) {
|
| 1826 |
|
|
if (!err)
|
| 1827 |
|
|
err = -EIO;
|
| 1828 |
|
|
goto shrink_mftbmp_err_ret;
|
| 1829 |
|
|
}
|
| 1830 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Read %lu bytes.\n", __FUNCTION__,
|
| 1831 |
|
|
(unsigned long)io.size);
|
| 1832 |
|
|
#ifdef DEBUG
|
| 1833 |
|
|
/* Check our bit is really zero! */
|
| 1834 |
|
|
if (*buf & (1 << (bit & 7)))
|
| 1835 |
|
|
BUG();
|
| 1836 |
|
|
#endif
|
| 1837 |
|
|
*buf |= 1 << (bit & 7);
|
| 1838 |
|
|
io.param = buf;
|
| 1839 |
|
|
io.do_read = 0;
|
| 1840 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
|
| 1841 |
|
|
if (err || io.size != 1) {
|
| 1842 |
|
|
if (!err)
|
| 1843 |
|
|
err = -EIO;
|
| 1844 |
|
|
goto shrink_mftbmp_err_ret;
|
| 1845 |
|
|
}
|
| 1846 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Wrote %lu bytes.\n", __FUNCTION__,
|
| 1847 |
|
|
(unsigned long)io.size);
|
| 1848 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After update: bmp->allocated = 0x%Lx, "
|
| 1849 |
|
|
"bmp->size = 0x%Lx, bmp->initialized = 0x%Lx.\n",
|
| 1850 |
|
|
__FUNCTION__, bmp->allocated,
|
| 1851 |
|
|
bmp->size, bmp->initialized);
|
| 1852 |
|
|
/* The mft bitmap is now uptodate. Deal with mft data attribute now. */
|
| 1853 |
|
|
ll = (__s64)(bit + 1) << vol->mft_record_size_bits;
|
| 1854 |
|
|
if (ll <= data->initialized) {
|
| 1855 |
|
|
/* The allocated record is already initialized. We are done! */
|
| 1856 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Allocated mft record "
|
| 1857 |
|
|
"already initialized!\n", __FUNCTION__);
|
| 1858 |
|
|
goto done_ret;
|
| 1859 |
|
|
}
|
| 1860 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Allocated mft record needs "
|
| 1861 |
|
|
"to be initialized.\n", __FUNCTION__);
|
| 1862 |
|
|
/* The mft record is outside the initialized data. */
|
| 1863 |
|
|
mft_rec_size = (unsigned long)vol->mft_record_size;
|
| 1864 |
|
|
/* Preserve old values for undo purposes. */
|
| 1865 |
|
|
old_data_allocated = data->allocated;
|
| 1866 |
|
|
old_data_rlen = data->d.r.len - 1;
|
| 1867 |
|
|
old_data_len = data->d.r.runlist[old_data_rlen].len;
|
| 1868 |
|
|
/*
|
| 1869 |
|
|
* If necessary, extend the mft until it covers the allocated record.
|
| 1870 |
|
|
* The loop is only actually used when a freshly formatted volume is
|
| 1871 |
|
|
* first written to. But it optimizes away nicely in the common case.
|
| 1872 |
|
|
*/
|
| 1873 |
|
|
while (ll > data->allocated) {
|
| 1874 |
|
|
ntfs_cluster_t lcn2, nr_lcn2, nr, min_nr;
|
| 1875 |
|
|
|
| 1876 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Extending mft data allocation, "
|
| 1877 |
|
|
"data->allocated = 0x%Lx, data->size = 0x%Lx, "
|
| 1878 |
|
|
"data->initialized = 0x%Lx.\n", __FUNCTION__,
|
| 1879 |
|
|
data->allocated, data->size, data->initialized);
|
| 1880 |
|
|
/* Minimum allocation is one mft record worth of clusters. */
|
| 1881 |
|
|
if (mft_rec_size <= vol->cluster_size)
|
| 1882 |
|
|
min_nr = (ntfs_cluster_t)1;
|
| 1883 |
|
|
else
|
| 1884 |
|
|
min_nr = mft_rec_size >> vol->cluster_size_bits;
|
| 1885 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): min_nr = %i.\n", __FUNCTION__,
|
| 1886 |
|
|
min_nr);
|
| 1887 |
|
|
/* Allocate 16 mft records worth of clusters. */
|
| 1888 |
|
|
nr = mft_rec_size << 4 >> vol->cluster_size_bits;
|
| 1889 |
|
|
if (!nr)
|
| 1890 |
|
|
nr = (ntfs_cluster_t)1;
|
| 1891 |
|
|
/* Determine the preferred allocation location. */
|
| 1892 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): nr = %i.\n", __FUNCTION__, nr);
|
| 1893 |
|
|
rl2 = data->d.r.runlist;
|
| 1894 |
|
|
r2len = data->d.r.len;
|
| 1895 |
|
|
lcn2 = rl2[r2len - 1].lcn + rl2[r2len - 1].len;
|
| 1896 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): rl2[r2len - 1].lcn = %i, .len = "
|
| 1897 |
|
|
"%i.\n", __FUNCTION__, rl2[r2len - 1].lcn,
|
| 1898 |
|
|
rl2[r2len - 1].len);
|
| 1899 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): lcn2 = %i, r2len = %i.\n",
|
| 1900 |
|
|
__FUNCTION__, lcn2, r2len);
|
| 1901 |
|
|
retry_mft_data_allocation:
|
| 1902 |
|
|
nr_lcn2 = nr;
|
| 1903 |
|
|
err = ntfs_allocate_clusters(vol, &lcn2, &nr_lcn2, &rl2,
|
| 1904 |
|
|
&r2len, MFT_ZONE);
|
| 1905 |
|
|
#ifdef DEBUG
|
| 1906 |
|
|
if (!err && nr_lcn2 < min_nr)
|
| 1907 |
|
|
/* Allocated less than minimum needed. Weird! */
|
| 1908 |
|
|
BUG();
|
| 1909 |
|
|
#endif
|
| 1910 |
|
|
if (err) {
|
| 1911 |
|
|
/*
|
| 1912 |
|
|
* If there isn't enough space to do the wanted
|
| 1913 |
|
|
* allocation, but there is enough space to do a
|
| 1914 |
|
|
* minimal allocation, then try that, unless the wanted
|
| 1915 |
|
|
* allocation was already the minimal allocation.
|
| 1916 |
|
|
*/
|
| 1917 |
|
|
if (err == -ENOSPC && nr > min_nr &&
|
| 1918 |
|
|
nr_lcn2 >= min_nr) {
|
| 1919 |
|
|
nr = min_nr;
|
| 1920 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Retrying mft "
|
| 1921 |
|
|
"data allocation, nr = min_nr "
|
| 1922 |
|
|
"= %i.\n", __FUNCTION__, nr);
|
| 1923 |
|
|
goto retry_mft_data_allocation;
|
| 1924 |
|
|
}
|
| 1925 |
|
|
goto undo_mftbmp_alloc_err_ret;
|
| 1926 |
|
|
}
|
| 1927 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Allocated %i clusters starting "
|
| 1928 |
|
|
"at LCN %i.\n", __FUNCTION__, nr_lcn2, lcn2);
|
| 1929 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Allocated runlist:\n",
|
| 1930 |
|
|
__FUNCTION__);
|
| 1931 |
|
|
dump_runlist(rl2, r2len);
|
| 1932 |
|
|
/* Append rl2 to the mft data attribute's run list. */
|
| 1933 |
|
|
err = splice_runlists(&data->d.r.runlist, (int*)&data->d.r.len,
|
| 1934 |
|
|
rl2, r2len);
|
| 1935 |
|
|
if (err) {
|
| 1936 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): splice_runlists failed "
|
| 1937 |
|
|
"with error code %i.\n", __FUNCTION__,
|
| 1938 |
|
|
-err);
|
| 1939 |
|
|
goto undo_partial_data_alloc_err_ret;
|
| 1940 |
|
|
}
|
| 1941 |
|
|
/* Reflect the allocated clusters in the mft allocated data. */
|
| 1942 |
|
|
data->allocated += nr_lcn2 << vol->cluster_size_bits;
|
| 1943 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After extending mft data "
|
| 1944 |
|
|
"allocation, data->allocated = 0x%Lx, "
|
| 1945 |
|
|
"data->size = 0x%Lx, data->initialized = "
|
| 1946 |
|
|
"0x%Lx.\n", __FUNCTION__, data->allocated,
|
| 1947 |
|
|
data->size, data->initialized);
|
| 1948 |
|
|
}
|
| 1949 |
|
|
/* Prepare a formatted (empty) mft record. */
|
| 1950 |
|
|
memset(buf, 0, mft_rec_size);
|
| 1951 |
|
|
ntfs_fill_mft_header(buf, mft_rec_size, 0, 0, 0);
|
| 1952 |
|
|
err = ntfs_insert_fixups(buf, mft_rec_size);
|
| 1953 |
|
|
if (err)
|
| 1954 |
|
|
goto undo_data_alloc_err_ret;
|
| 1955 |
|
|
/*
|
| 1956 |
|
|
* Extend mft data initialized size to reach the allocated mft record
|
| 1957 |
|
|
* and write the formatted mft record buffer to each mft record being
|
| 1958 |
|
|
* initialized. Note, that ntfs_readwrite_attr extends both
|
| 1959 |
|
|
* data->initialized and data->size, so no need for us to touch them.
|
| 1960 |
|
|
*/
|
| 1961 |
|
|
old_data_initialized = data->initialized;
|
| 1962 |
|
|
old_data_size = data->size;
|
| 1963 |
|
|
while (ll > data->initialized) {
|
| 1964 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Initializing mft record "
|
| 1965 |
|
|
"0x%Lx.\n", __FUNCTION__,
|
| 1966 |
|
|
data->initialized >> vol->mft_record_size_bits);
|
| 1967 |
|
|
io.param = buf;
|
| 1968 |
|
|
io.size = mft_rec_size;
|
| 1969 |
|
|
io.do_read = 0;
|
| 1970 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, data,
|
| 1971 |
|
|
data->initialized, &io);
|
| 1972 |
|
|
if (err || io.size != mft_rec_size) {
|
| 1973 |
|
|
if (!err)
|
| 1974 |
|
|
err = -EIO;
|
| 1975 |
|
|
goto undo_data_init_err_ret;
|
| 1976 |
|
|
}
|
| 1977 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Wrote %i bytes to mft data.\n",
|
| 1978 |
|
|
__FUNCTION__, io.size);
|
| 1979 |
|
|
}
|
| 1980 |
|
|
/* Update the VFS inode size as well. */
|
| 1981 |
|
|
VFS_I(vol->mft_ino)->i_size = data->size;
|
| 1982 |
|
|
#ifdef DEBUG
|
| 1983 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): After mft record "
|
| 1984 |
|
|
"initialization: data->allocated = 0x%Lx, data->size "
|
| 1985 |
|
|
"= 0x%Lx, data->initialized = 0x%Lx.\n", __FUNCTION__,
|
| 1986 |
|
|
data->allocated, data->size, data->initialized);
|
| 1987 |
|
|
/* Sanity checks. */
|
| 1988 |
|
|
if (data->size > data->allocated || data->size < data->initialized ||
|
| 1989 |
|
|
data->initialized > data->allocated)
|
| 1990 |
|
|
BUG();
|
| 1991 |
|
|
#endif
|
| 1992 |
|
|
done_ret:
|
| 1993 |
|
|
/* Return the number of the allocated mft record. */
|
| 1994 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At done_ret. *result = bit = 0x%lx.\n",
|
| 1995 |
|
|
__FUNCTION__, bit);
|
| 1996 |
|
|
*result = bit;
|
| 1997 |
|
|
vol->mft_data_pos = bit + 1;
|
| 1998 |
|
|
err_ret:
|
| 1999 |
|
|
unlock_kernel();
|
| 2000 |
|
|
free_page((unsigned long)buf);
|
| 2001 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): Syncing inode $MFT.\n", __FUNCTION__);
|
| 2002 |
|
|
if (ntfs_update_inode(vol->mft_ino))
|
| 2003 |
|
|
ntfs_error("%s(): Failed to sync inode $MFT. "
|
| 2004 |
|
|
"Continuing anyway.\n",__FUNCTION__);
|
| 2005 |
|
|
if (!err) {
|
| 2006 |
|
|
ntfs_debug(DEBUG_FILE3, "%s(): Done. Allocated mft record "
|
| 2007 |
|
|
"number *result = 0x%lx.\n", __FUNCTION__,
|
| 2008 |
|
|
*result);
|
| 2009 |
|
|
return 0;
|
| 2010 |
|
|
}
|
| 2011 |
|
|
if (err != -ENOSPC)
|
| 2012 |
|
|
ntfs_error("%s(): Failed to allocate an mft record. Returning "
|
| 2013 |
|
|
"error code %i.\n", __FUNCTION__, -err);
|
| 2014 |
|
|
else
|
| 2015 |
|
|
ntfs_debug(DEBUG_FILE3, "%s(): Failed to allocate an mft "
|
| 2016 |
|
|
"record due to lack of free space.\n",
|
| 2017 |
|
|
__FUNCTION__);
|
| 2018 |
|
|
return err;
|
| 2019 |
|
|
undo_data_init_err_ret:
|
| 2020 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At undo_data_init_err_ret.\n",
|
| 2021 |
|
|
__FUNCTION__);
|
| 2022 |
|
|
data->initialized = old_data_initialized;
|
| 2023 |
|
|
data->size = old_data_size;
|
| 2024 |
|
|
undo_data_alloc_err_ret:
|
| 2025 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At undo_data_alloc_err_ret.\n",
|
| 2026 |
|
|
__FUNCTION__);
|
| 2027 |
|
|
data->allocated = old_data_allocated;
|
| 2028 |
|
|
undo_partial_data_alloc_err_ret:
|
| 2029 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At undo_partial_data_alloc_err_ret.\n",
|
| 2030 |
|
|
__FUNCTION__);
|
| 2031 |
|
|
/* Deallocate the clusters. */
|
| 2032 |
|
|
if (ntfs_deallocate_clusters(vol, rl2, r2len))
|
| 2033 |
|
|
ntfs_error("%s(): Error deallocating clusters in error code "
|
| 2034 |
|
|
"path. You should run chkdsk.\n", __FUNCTION__);
|
| 2035 |
|
|
ntfs_vfree(rl2);
|
| 2036 |
|
|
/* Revert the run list back to what it was before. */
|
| 2037 |
|
|
r2len = data->d.r.len;
|
| 2038 |
|
|
rl2 = data->d.r.runlist;
|
| 2039 |
|
|
rl2[old_data_rlen++].len = old_data_len;
|
| 2040 |
|
|
rl2[old_data_rlen].lcn = (ntfs_cluster_t)-1;
|
| 2041 |
|
|
rl2[old_data_rlen].len = (ntfs_cluster_t)0;
|
| 2042 |
|
|
data->d.r.len = old_data_rlen;
|
| 2043 |
|
|
rl2_size = ((old_data_rlen + 1) * sizeof(ntfs_runlist) + PAGE_SIZE -
|
| 2044 |
|
|
1) & PAGE_MASK;
|
| 2045 |
|
|
/* Reallocate memory freeing any extra memory allocated. */
|
| 2046 |
|
|
if (rl2_size < ((r2len * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
|
| 2047 |
|
|
PAGE_MASK)) {
|
| 2048 |
|
|
rl2 = ntfs_vmalloc(rl2_size);
|
| 2049 |
|
|
if (rl2) {
|
| 2050 |
|
|
ntfs_memcpy(rl2, data->d.r.runlist, rl2_size);
|
| 2051 |
|
|
ntfs_vfree(data->d.r.runlist);
|
| 2052 |
|
|
data->d.r.runlist = rl2;
|
| 2053 |
|
|
} else
|
| 2054 |
|
|
ntfs_error("%s(): Error reallocating "
|
| 2055 |
|
|
"memory in error code path. This "
|
| 2056 |
|
|
"should be harmless.\n", __FUNCTION__);
|
| 2057 |
|
|
}
|
| 2058 |
|
|
undo_mftbmp_alloc_err_ret:
|
| 2059 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At undo_mftbmp_alloc_err_ret.\n",
|
| 2060 |
|
|
__FUNCTION__);
|
| 2061 |
|
|
/* Deallocate the allocated bit in the mft bitmap. */
|
| 2062 |
|
|
io.param = buf;
|
| 2063 |
|
|
io.size = 1;
|
| 2064 |
|
|
io.do_read = 1;
|
| 2065 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
|
| 2066 |
|
|
if (!err && io.size == 1) {
|
| 2067 |
|
|
*buf &= ~(1 << (bit & 7));
|
| 2068 |
|
|
io.param = buf;
|
| 2069 |
|
|
io.do_read = 0;
|
| 2070 |
|
|
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
|
| 2071 |
|
|
}
|
| 2072 |
|
|
if (err || io.size != 1) {
|
| 2073 |
|
|
if (!err)
|
| 2074 |
|
|
err = -EIO;
|
| 2075 |
|
|
ntfs_error("%s(): Error deallocating mft record in error code "
|
| 2076 |
|
|
"path. You should run chkdsk.\n", __FUNCTION__);
|
| 2077 |
|
|
}
|
| 2078 |
|
|
shrink_mftbmp_err_ret:
|
| 2079 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): At shrink_mftbmp_err_ret.\n",
|
| 2080 |
|
|
__FUNCTION__);
|
| 2081 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): have_allocated_mftbmp = %i.\n",
|
| 2082 |
|
|
__FUNCTION__, have_allocated_mftbmp);
|
| 2083 |
|
|
if (!have_allocated_mftbmp)
|
| 2084 |
|
|
goto err_ret;
|
| 2085 |
|
|
/* Shrink the mftbmp back to previous size. */
|
| 2086 |
|
|
if (bmp->size == bmp->initialized)
|
| 2087 |
|
|
bmp->size -= 8LL;
|
| 2088 |
|
|
bmp->initialized -= 8LL;
|
| 2089 |
|
|
have_allocated_mftbmp &= ~4;
|
| 2090 |
|
|
/* If no allocation occured then we are done. */
|
| 2091 |
|
|
ntfs_debug(DEBUG_OTHER, "%s(): have_allocated_mftbmp = %i.\n",
|
| 2092 |
|
|
__FUNCTION__, have_allocated_mftbmp);
|
| 2093 |
|
|
if (!have_allocated_mftbmp)
|
| 2094 |
|
|
goto err_ret;
|
| 2095 |
|
|
/* Deallocate the allocated cluster. */
|
| 2096 |
|
|
bmp->allocated -= (__s64)vol->cluster_size;
|
| 2097 |
|
|
if (ntfs_deallocate_cluster_run(vol, lcn, (ntfs_cluster_t)1))
|
| 2098 |
|
|
ntfs_error("%s(): Error deallocating cluster in error code "
|
| 2099 |
|
|
"path. You should run chkdsk.\n", __FUNCTION__);
|
| 2100 |
|
|
switch (have_allocated_mftbmp & 3) {
|
| 2101 |
|
|
case 1:
|
| 2102 |
|
|
/* Delete the last lcn from the last run of mftbmp. */
|
| 2103 |
|
|
rl[rlen - 1].len--;
|
| 2104 |
|
|
break;
|
| 2105 |
|
|
case 2:
|
| 2106 |
|
|
/* Delete the last run of mftbmp. */
|
| 2107 |
|
|
bmp->d.r.len = --rlen;
|
| 2108 |
|
|
/* Reallocate memory if necessary. */
|
| 2109 |
|
|
if ((rlen + 1) * sizeof(ntfs_runlist) <= rl_size - PAGE_SIZE) {
|
| 2110 |
|
|
ntfs_runlist *rlt;
|
| 2111 |
|
|
|
| 2112 |
|
|
rl_size -= PAGE_SIZE;
|
| 2113 |
|
|
rlt = ntfs_vmalloc(rl_size);
|
| 2114 |
|
|
if (rlt) {
|
| 2115 |
|
|
ntfs_memcpy(rlt, rl, rl_size);
|
| 2116 |
|
|
ntfs_vfree(rl);
|
| 2117 |
|
|
bmp->d.r.runlist = rl = rlt;
|
| 2118 |
|
|
} else
|
| 2119 |
|
|
ntfs_error("%s(): Error "
|
| 2120 |
|
|
"reallocating memory in error "
|
| 2121 |
|
|
"code path. This should be "
|
| 2122 |
|
|
"harmless.\n", __FUNCTION__);
|
| 2123 |
|
|
}
|
| 2124 |
|
|
bmp->d.r.runlist[bmp->d.r.len].lcn = (ntfs_cluster_t)-1;
|
| 2125 |
|
|
bmp->d.r.runlist[bmp->d.r.len].len = (ntfs_cluster_t)0;
|
| 2126 |
|
|
break;
|
| 2127 |
|
|
default:
|
| 2128 |
|
|
BUG();
|
| 2129 |
|
|
}
|
| 2130 |
|
|
goto err_ret;
|
| 2131 |
|
|
}
|
| 2132 |
|
|
|
| 2133 |
|
|
/* We need 0x48 bytes in total. */
|
| 2134 |
|
|
static int add_standard_information(ntfs_inode *ino)
|
| 2135 |
|
|
{
|
| 2136 |
|
|
ntfs_time64_t now;
|
| 2137 |
|
|
char data[0x30];
|
| 2138 |
|
|
char *position = data;
|
| 2139 |
|
|
ntfs_attribute *si;
|
| 2140 |
|
|
|
| 2141 |
|
|
now = ntfs_now();
|
| 2142 |
|
|
NTFS_PUTU64(position + 0x00, now); /* File creation */
|
| 2143 |
|
|
NTFS_PUTU64(position + 0x08, now); /* Last modification */
|
| 2144 |
|
|
NTFS_PUTU64(position + 0x10, now); /* Last mod for MFT */
|
| 2145 |
|
|
NTFS_PUTU64(position + 0x18, now); /* Last access */
|
| 2146 |
|
|
NTFS_PUTU64(position + 0x20, 0); /* MSDOS file perms */
|
| 2147 |
|
|
NTFS_PUTU64(position + 0x28, 0); /* unknown */
|
| 2148 |
|
|
return ntfs_create_attr(ino, ino->vol->at_standard_information, 0,
|
| 2149 |
|
|
data, sizeof(data), &si);
|
| 2150 |
|
|
}
|
| 2151 |
|
|
|
| 2152 |
|
|
static int add_filename(ntfs_inode *ino, ntfs_inode *dir,
|
| 2153 |
|
|
const unsigned char *filename, int length, ntfs_u32 flags)
|
| 2154 |
|
|
{
|
| 2155 |
|
|
unsigned char *position;
|
| 2156 |
|
|
unsigned int size;
|
| 2157 |
|
|
ntfs_time64_t now;
|
| 2158 |
|
|
int count, error;
|
| 2159 |
|
|
unsigned char* data;
|
| 2160 |
|
|
ntfs_attribute *fn;
|
| 2161 |
|
|
|
| 2162 |
|
|
/* Work out the size. */
|
| 2163 |
|
|
size = 0x42 + 2 * length;
|
| 2164 |
|
|
data = ntfs_malloc(size);
|
| 2165 |
|
|
if (!data)
|
| 2166 |
|
|
return -ENOMEM;
|
| 2167 |
|
|
/* Search for a position. */
|
| 2168 |
|
|
position = data;
|
| 2169 |
|
|
NTFS_PUTINUM(position, dir); /* Inode num of dir */
|
| 2170 |
|
|
now = ntfs_now();
|
| 2171 |
|
|
NTFS_PUTU64(position + 0x08, now); /* File creation */
|
| 2172 |
|
|
NTFS_PUTU64(position + 0x10, now); /* Last modification */
|
| 2173 |
|
|
NTFS_PUTU64(position + 0x18, now); /* Last mod for MFT */
|
| 2174 |
|
|
NTFS_PUTU64(position + 0x20, now); /* Last access */
|
| 2175 |
|
|
/* FIXME: Get the following two sizes by finding the data attribute
|
| 2176 |
|
|
* in ino->attr and copying the corresponding fields from there.
|
| 2177 |
|
|
* If no data present then set to zero. In current implementation
|
| 2178 |
|
|
* add_data is called after add_filename so zero is correct on
|
| 2179 |
|
|
* creation. Need to change when we have hard links / support different
|
| 2180 |
|
|
* filename namespaces. (AIA) */
|
| 2181 |
|
|
NTFS_PUTS64(position + 0x28, 0); /* Allocated size */
|
| 2182 |
|
|
NTFS_PUTS64(position + 0x30, 0); /* Data size */
|
| 2183 |
|
|
NTFS_PUTU32(position + 0x38, flags); /* File flags */
|
| 2184 |
|
|
NTFS_PUTU32(position + 0x3c, 0); /* We don't use these
|
| 2185 |
|
|
* features yet. */
|
| 2186 |
|
|
NTFS_PUTU8(position + 0x40, length); /* Filename length */
|
| 2187 |
|
|
NTFS_PUTU8(position + 0x41, 0); /* Only long name */
|
| 2188 |
|
|
/* FIXME: This is madness. We are defining the POSIX namespace
|
| 2189 |
|
|
* for the filename here which can mean that the file will be
|
| 2190 |
|
|
* invisible when in Windows NT/2k! )-: (AIA) */
|
| 2191 |
|
|
position += 0x42;
|
| 2192 |
|
|
for (count = 0; count < length; count++) {
|
| 2193 |
|
|
NTFS_PUTU16(position + 2 * count, filename[count]);
|
| 2194 |
|
|
}
|
| 2195 |
|
|
error = ntfs_create_attr(ino, ino->vol->at_file_name, 0, data, size,
|
| 2196 |
|
|
&fn);
|
| 2197 |
|
|
if (!error)
|
| 2198 |
|
|
error = ntfs_dir_add(dir, ino, fn);
|
| 2199 |
|
|
ntfs_free(data);
|
| 2200 |
|
|
return error;
|
| 2201 |
|
|
}
|
| 2202 |
|
|
|
| 2203 |
|
|
int add_security(ntfs_inode* ino, ntfs_inode* dir)
|
| 2204 |
|
|
{
|
| 2205 |
|
|
int error;
|
| 2206 |
|
|
char *buf;
|
| 2207 |
|
|
int size;
|
| 2208 |
|
|
ntfs_attribute* attr;
|
| 2209 |
|
|
ntfs_io io;
|
| 2210 |
|
|
ntfs_attribute *se;
|
| 2211 |
|
|
|
| 2212 |
|
|
attr = ntfs_find_attr(dir, ino->vol->at_security_descriptor, 0);
|
| 2213 |
|
|
if (!attr)
|
| 2214 |
|
|
return -EOPNOTSUPP; /* Need security in directory. */
|
| 2215 |
|
|
size = attr->size;
|
| 2216 |
|
|
if (size > 512)
|
| 2217 |
|
|
return -EOPNOTSUPP;
|
| 2218 |
|
|
buf = ntfs_malloc(size);
|
| 2219 |
|
|
if (!buf)
|
| 2220 |
|
|
return -ENOMEM;
|
| 2221 |
|
|
io.fn_get = ntfs_get;
|
| 2222 |
|
|
io.fn_put = ntfs_put;
|
| 2223 |
|
|
io.param = buf;
|
| 2224 |
|
|
io.size = size;
|
| 2225 |
|
|
error = ntfs_read_attr(dir, ino->vol->at_security_descriptor, 0, 0,&io);
|
| 2226 |
|
|
if (!error && io.size != size)
|
| 2227 |
|
|
ntfs_error("wrong size in add_security\n");
|
| 2228 |
|
|
if (error) {
|
| 2229 |
|
|
ntfs_free(buf);
|
| 2230 |
|
|
return error;
|
| 2231 |
|
|
}
|
| 2232 |
|
|
/* FIXME: Consider ACL inheritance. */
|
| 2233 |
|
|
error = ntfs_create_attr(ino, ino->vol->at_security_descriptor,
|
| 2234 |
|
|
0, buf, size, &se);
|
| 2235 |
|
|
ntfs_free(buf);
|
| 2236 |
|
|
return error;
|
| 2237 |
|
|
}
|
| 2238 |
|
|
|
| 2239 |
|
|
static int add_data(ntfs_inode* ino, unsigned char *data, int length)
|
| 2240 |
|
|
{
|
| 2241 |
|
|
ntfs_attribute *da;
|
| 2242 |
|
|
|
| 2243 |
|
|
return ntfs_create_attr(ino, ino->vol->at_data, 0, data, length, &da);
|
| 2244 |
|
|
}
|
| 2245 |
|
|
|
| 2246 |
|
|
/*
|
| 2247 |
|
|
* We _could_ use 'dir' to help optimise inode allocation.
|
| 2248 |
|
|
*
|
| 2249 |
|
|
* FIXME: Need to undo what we do in ntfs_alloc_mft_record if we get an error
|
| 2250 |
|
|
* further on in ntfs_alloc_inode. Either fold the two functions to allow
|
| 2251 |
|
|
* proper undo or just deallocate the record from the mft bitmap. (AIA)
|
| 2252 |
|
|
*/
|
| 2253 |
|
|
int ntfs_alloc_inode(ntfs_inode *dir, ntfs_inode *result, const char *filename,
|
| 2254 |
|
|
int namelen, ntfs_u32 flags)
|
| 2255 |
|
|
{
|
| 2256 |
|
|
ntfs_volume *vol = dir->vol;
|
| 2257 |
|
|
int err;
|
| 2258 |
|
|
ntfs_u8 buffer[2];
|
| 2259 |
|
|
ntfs_io io;
|
| 2260 |
|
|
|
| 2261 |
|
|
err = ntfs_alloc_mft_record(vol, &(result->i_number));
|
| 2262 |
|
|
if (err) {
|
| 2263 |
|
|
if (err == -ENOSPC)
|
| 2264 |
|
|
ntfs_error("%s(): No free inodes.\n", __FUNCTION__);
|
| 2265 |
|
|
return err;
|
| 2266 |
|
|
}
|
| 2267 |
|
|
/* Get the sequence number. */
|
| 2268 |
|
|
io.fn_put = ntfs_put;
|
| 2269 |
|
|
io.fn_get = ntfs_get;
|
| 2270 |
|
|
io.param = buffer;
|
| 2271 |
|
|
io.size = 2;
|
| 2272 |
|
|
err = ntfs_read_attr(vol->mft_ino, vol->at_data, 0,
|
| 2273 |
|
|
((__s64)result->i_number << vol->mft_record_size_bits)
|
| 2274 |
|
|
+ 0x10, &io);
|
| 2275 |
|
|
// FIXME: We are leaving the MFT in inconsistent state! (AIA)
|
| 2276 |
|
|
if (err)
|
| 2277 |
|
|
return err;
|
| 2278 |
|
|
/* Increment the sequence number skipping zero. */
|
| 2279 |
|
|
result->sequence_number = (NTFS_GETU16(buffer) + 1) & 0xffff;
|
| 2280 |
|
|
if (!result->sequence_number)
|
| 2281 |
|
|
result->sequence_number++;
|
| 2282 |
|
|
result->vol = vol;
|
| 2283 |
|
|
result->attr_count = 0;
|
| 2284 |
|
|
result->attrs = 0;
|
| 2285 |
|
|
result->record_count = 1;
|
| 2286 |
|
|
result->records = ntfs_calloc(8 * sizeof(int));
|
| 2287 |
|
|
if (!result->records)
|
| 2288 |
|
|
goto mem_err_out;
|
| 2289 |
|
|
result->records[0] = result->i_number;
|
| 2290 |
|
|
result->attr = ntfs_calloc(vol->mft_record_size);
|
| 2291 |
|
|
if (!result->attr) {
|
| 2292 |
|
|
ntfs_free(result->records);
|
| 2293 |
|
|
result->records = NULL;
|
| 2294 |
|
|
goto mem_err_out;
|
| 2295 |
|
|
}
|
| 2296 |
|
|
ntfs_fill_mft_header(result->attr, vol->mft_record_size,
|
| 2297 |
|
|
result->sequence_number, 1, 1);
|
| 2298 |
|
|
err = add_standard_information(result);
|
| 2299 |
|
|
if (!err)
|
| 2300 |
|
|
err = add_filename(result, dir, filename, namelen, flags);
|
| 2301 |
|
|
if (!err)
|
| 2302 |
|
|
err = add_security(result, dir);
|
| 2303 |
|
|
// FIXME: We are leaving the MFT in inconsistent state on error! (AIA)
|
| 2304 |
|
|
return err;
|
| 2305 |
|
|
mem_err_out:
|
| 2306 |
|
|
// FIXME: We are leaving the MFT in inconsistent state! (AIA)
|
| 2307 |
|
|
result->record_count = 0;
|
| 2308 |
|
|
result->attr = NULL;
|
| 2309 |
|
|
return -ENOMEM;
|
| 2310 |
|
|
}
|
| 2311 |
|
|
|
| 2312 |
|
|
int ntfs_alloc_file(ntfs_inode *dir, ntfs_inode *result, char *filename,
|
| 2313 |
|
|
int namelen)
|
| 2314 |
|
|
{
|
| 2315 |
|
|
int err;
|
| 2316 |
|
|
|
| 2317 |
|
|
err = ntfs_alloc_inode(dir, result, filename, namelen, 0);
|
| 2318 |
|
|
if (!err)
|
| 2319 |
|
|
err = add_data(result, 0, 0);
|
| 2320 |
|
|
return err;
|
| 2321 |
|
|
}
|
| 2322 |
|
|
|
