fs/ntfs/inode.c

   1 /*
   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, __FUNCTION__ "(): %s 0x%x bytes at offset "
 675                         "0x%Lx %s inode 0x%x, attr type 0x%x.\n",
 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, __FUNCTION__ "(): EOPNOTSUPP: "
 750                         "inode = 0x%x, rnum = %i, offset = 0x%Lx, vcn = 0x%x, "
 751                         "s_vcn = 0x%x.\n", ino->i_number, rnum, offset, vcn,
 752                         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, __FUNCTION__ "(): attr 0x%x not found "
 797                                 "in inode 0x%x\n", 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, __FUNCTION__ "(): attr 0x%x not found "
 812                                 "in inode 0x%x\n", 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, __FUNCTION__ "(): rlen = %i.\n", 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, __FUNCTION__ "(): Entering with *r1len = %i, "
1376                         "r2len = %i.\n", *r1len, r2len);
1377         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Dumping 1st runlist.\n");
1378         if (*rl1)
1379                 dump_runlist(*rl1, *r1len);
1380         else
1381                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Not present.\n");
1382         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Dumping 2nd runlist.\n");
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, __FUNCTION__ "(): rlen = %i, rl_size = %i.\n",
1388                         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, __FUNCTION__ "(): Have enough space "
1395                                 "already.\n");
1396         } else {
1397                 /* Need more space. Reallocate. */
1398                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Need more space.\n");
1399                 rl = ntfs_vmalloc(rlen << sizeof(ntfs_runlist));
1400                 if (!rl)
1401                         return -ENOMEM;
1402                 /* Copy over rl1. */
1403                 ntfs_memcpy(rl, *rl1, *r1len * sizeof(ntfs_runlist));
1404                 ntfs_vfree(*rl1);
1405                 *rl1 = rl;
1406         }
1407         /* Reuse rl_size as the current position index into rl. */
1408         rl_size = *r1len - 1;
1409         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rl_size = %i.\n");
1410         /* Coalesce neighbouring elements, if present. */
1411         rl2_pos = 0;
1412         if (rl[rl_size].lcn + rl[rl_size].len == rl2[rl2_pos].lcn) {
1413                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Coalescing adjacent "
1414                                 "runs.\n");
1415                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
1416                                 "rl[rl_size].len = %i.\n", rl[rl_size].len);
1417                 rl[rl_size].len += rl2[rl2_pos].len;
1418                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
1419                                 "rl[rl_size].len = %i.\n", rl[rl_size].len);
1420                 rl2_pos++;
1421                 r2len--;
1422                 rlen--;
1423         }
1424         rl_size++;
1425         /* Copy over rl2. */
1426         ntfs_memcpy(rl + rl_size, rl2 + rl2_pos, r2len * sizeof(ntfs_runlist));
1427         rlen--;
1428         rl[rlen].lcn = (ntfs_cluster_t)-1;
1429         rl[rlen].len = (ntfs_cluster_t)0;
1430         *r1len = rlen;
1431         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Dumping result runlist.\n");
1432         dump_runlist(*rl1, *r1len);
1433         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Returning with *r1len = "
1434                         "%i.\n", rlen);
1435         return 0;
1436 }
1437
1438 /**
1439  * ntfs_alloc_mft_record - allocate an mft record
1440  * @vol:        volume to allocate an mft record on
1441  * @result:     the mft record number allocated
1442  *
1443  * Allocate a new mft record on disk. Return 0 on success or -ERRNO on error.
1444  * On success, *@result contains the allocated mft record number. On error,
1445  * *@result is -1UL.
1446  *
1447  * Note, this function doesn't actually set the mft record to be in use. This
1448  * is done by the caller, which at the moment is only ntfs_alloc_inode().
1449  *
1450  * To find a free mft record, we scan the mft bitmap for a zero bit. To
1451  * optimize this we start scanning at the place where we last stopped and we
1452  * perform wrap around when we reach the end. Note, we do not try to allocate
1453  * mft records below number 24 because numbers 0 to 15 are the defined system
1454  * files anyway and 16 to 24 are special in that they are used for storing
1455  * extension mft records for $MFT's $DATA attribute. This is required to avoid
1456  * the possibility of creating a run list with a circular dependence which once
1457  * written to disk can never be read in again. Windows will only use records
1458  * 16 to 24 for normal files if the volume is completely out of space. We never
1459  * use them which means that when the volume is really out of space we cannot
1460  * create any more files while Windows can still create up to 8 small files. We
1461  * can start doing this at some later time, doesn't matter much for now.
1462  *
1463  * When scanning the mft bitmap, we only search up to the last allocated mft
1464  * record. If there are no free records left in the range 24 to number of
1465  * allocated mft records, then we extend the mft data in order to create free
1466  * mft records. We extend the allocated size of $MFT/$DATA by 16 records at a
1467  * time or one cluster, if cluster size is above 16kiB. If there isn't
1468  * sufficient space to do this, we try to extend by a single mft record or one
1469  * cluster, if cluster size is above mft record size, but we only do this if
1470  * there is enough free space, which we know from the values returned by the
1471  * failed cluster allocation function when we tried to do the first allocation.
1472  *
1473  * No matter how many mft records we allocate, we initialize only the first
1474  * allocated mft record (incrementing mft data size and initialized size) and
1475  * return its number to the caller in @*result, unless there are less than 24
1476  * mft records, in which case we allocate and initialize mft records until we
1477  * reach record 24 which we consider as the first free mft record for use by
1478  * normal files.
1479  *
1480  * If during any stage we overflow the initialized data in the mft bitmap, we
1481  * extend the initialized size (and data size) by 8 bytes, allocating another
1482  * cluster if required. The bitmap data size has to be at least equal to the
1483  * number of mft records in the mft, but it can be bigger, in which case the
1484  * superflous bits are padded with zeroes.
1485  *
1486  * Thus, when we return successfully (return value 0), we will have:
1487  *      - initialized / extended the mft bitmap if necessary,
1488  *      - initialized / extended the mft data if necessary,
1489  *      - set the bit corresponding to the mft record being allocated in the
1490  *        mft bitmap, and we will
1491  *      - return the mft record number in @*result.
1492  *
1493  * On error (return value below zero), nothing will have changed. If we had
1494  * changed anything before the error occured, we will have reverted back to
1495  * the starting state before returning to the caller. Thus, except for bugs,
1496  * we should always leave the volume in a consitents state when returning from
1497  * this function. NOTE: Small exception to this is that we set the bit in the
1498  * mft bitmap but we do not mark the mft record in use, which is inconsistent.
1499  * However, the caller will immediately add the wanted attributes to the mft
1500  * record, set it in use and write it out to disk, so there should be no
1501  * problem.
1502  *
1503  * Note, this function cannot make use of most of the normal functions, like
1504  * for example for attribute resizing, etc, because when the run list overflows
1505  * the base mft record and an attribute list is used, it is very important
1506  * that the extension mft records used to store the $DATA attribute of $MFT
1507  * can be reached without having to read the information contained inside
1508  * them, as this would make it impossible to find them in the first place
1509  * after the volume is dismounted. $MFT/$BITMAP probably doesn't need to
1510  * follow this rule because the bitmap is not essential for finding the mft
1511  * records, but on the other hand, handling the bitmap in this special way
1512  * would make life easier because otherwise there might be circular invocations
1513  * of functions when reading the bitmap but if we are careful, we should be
1514  * able to avoid all problems.
1515  *
1516  * FIXME: Don't forget $MftMirr, though this probably belongs in
1517  *        ntfs_update_inode() (or even deeper). (AIA)
1518  *
1519  * FIXME: Want finer grained locking. (AIA)
1520  */
1521 static int ntfs_alloc_mft_record(ntfs_volume *vol, unsigned long *result)
1522 {
1523         unsigned long nr_mft_records, buf_size, buf_pos, pass_start, pass_end;
1524         unsigned long last_read_pos, mft_rec_size, bit, l;
1525         ntfs_attribute *data, *bmp;
1526         __u8 *buf, *byte, pass, b, have_allocated_mftbmp = 0;
1527         int rlen, rl_size = 0, r2len, rl2_size, old_data_rlen, err = 0;
1528         ntfs_runlist *rl, *rl2;
1529         ntfs_cluster_t lcn = 0, old_data_len;
1530         ntfs_io io;
1531         __s64 ll, old_data_allocated, old_data_initialized, old_data_size;
1532
1533         *result = -1UL;
1534         /* Allocate a buffer and setup the io structure. */
1535         buf = (__u8*)__get_free_page(GFP_NOFS);
1536         if (!buf)
1537                 return -ENOMEM;
1538         lock_kernel();
1539         /* Get the $DATA and $BITMAP attributes of $MFT. */
1540         data = ntfs_find_attr(vol->mft_ino, vol->at_data, 0);
1541         bmp = ntfs_find_attr(vol->mft_ino, vol->at_bitmap, 0);
1542         if (!data || !bmp) {
1543                 err = -EINVAL;
1544                 goto err_ret;
1545         }
1546         /* Determine the number of allocated mft records in the mft. */
1547         pass_end = nr_mft_records = data->allocated >>
1548                         vol->mft_record_size_bits;
1549         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): nr_mft_records = %lu.\n",
1550                         nr_mft_records);
1551         /* Make sure we don't overflow the bitmap. */
1552         l = bmp->initialized << 3;
1553         if (l < nr_mft_records)
1554                 // FIXME: It might be a good idea to extend the bitmap instead.
1555                 pass_end = l;
1556         pass = 1;
1557         buf_pos = vol->mft_data_pos;
1558         if (buf_pos >= pass_end) {
1559                 buf_pos = 24UL;
1560                 pass = 2;
1561         }
1562         pass_start = buf_pos;
1563         rl = bmp->d.r.runlist;
1564         rlen = bmp->d.r.len - 1;
1565         lcn = rl[rlen].lcn + rl[rlen].len;
1566         io.fn_put = ntfs_put;
1567         io.fn_get = ntfs_get;
1568         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Starting bitmap search.\n");
1569         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): pass = %i, pass_start = %lu, "
1570                         "pass_end = %lu.\n", pass, pass_start, pass_end);
1571         byte = NULL; // FIXME: For debugging only.
1572         /* Loop until a free mft record is found. */
1573         io.size = (nr_mft_records >> 3) & ~PAGE_MASK;
1574         for (;; io.size = PAGE_SIZE) {
1575                 io.param = buf;
1576                 io.do_read = 1;
1577                 last_read_pos = buf_pos >> 3;
1578                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
1579                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1580                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1581                                 bmp->size, bmp->initialized);
1582                 err = ntfs_readwrite_attr(vol->mft_ino, bmp, last_read_pos,
1583                                 &io);
1584                 if (err)
1585                         goto err_ret;
1586                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Read %lu bytes.\n",
1587                                 (unsigned long)io.size);
1588                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
1589                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1590                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1591                                 bmp->size, bmp->initialized);
1592                 if (!io.size)
1593                         goto pass_done;
1594                 buf_size = io.size << 3;
1595                 bit = buf_pos & 7UL;
1596                 buf_pos &= ~7UL;
1597                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before loop: "
1598                                 "buf_size = %lu, buf_pos = %lu, bit = %lu, "
1599                                 "*byte = 0x%x, b = %u.\n",
1600                                 buf_size, buf_pos, bit, byte ? *byte : -1, b);
1601                 for (; bit < buf_size && bit + buf_pos < pass_end;
1602                                 bit &= ~7UL, bit += 8UL) {
1603                         byte = buf + (bit >> 3);
1604                         if (*byte == 0xff)
1605                                 continue;
1606                         b = ffz((unsigned long)*byte);
1607                         if (b < (__u8)8 && b >= (bit & 7UL)) {
1608                                 bit = b + (bit & ~7UL) + buf_pos;
1609                                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
1610                                                 "Found free rec in for loop. "
1611                                                 "bit = %lu\n", bit);
1612                                 goto found_free_rec;
1613                         }
1614                 }
1615                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After loop: "
1616                                 "buf_size = %lu, buf_pos = %lu, bit = %lu, "
1617                                 "*byte = 0x%x, b = %u.\n",
1618                                 buf_size, buf_pos, bit, byte ? *byte : -1, b);
1619                 buf_pos += buf_size;
1620                 if (buf_pos < pass_end)
1621                         continue;
1622 pass_done:      /* Finished with the current pass. */
1623                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At pass_done.\n");
1624                 if (pass == 1) {
1625                         /*
1626                          * Now do pass 2, scanning the first part of the zone
1627                          * we omitted in pass 1.
1628                          */
1629                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Done pass "
1630                                         "1.\n");
1631                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Pass = 2.\n");
1632                         pass = 2;
1633                         pass_end = pass_start;
1634                         buf_pos = pass_start = 24UL;
1635                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): pass = %i, "
1636                                         "pass_start = %lu, pass_end = %lu.\n",
1637                                         pass, pass_start, pass_end);
1638                         continue;
1639                 } /* pass == 2 */
1640                 /* No free records left. */
1641                 if (bmp->initialized << 3 > nr_mft_records &&
1642                                 bmp->initialized > 3) {
1643                         /*
1644                          * The mft bitmap is already bigger but the space is
1645                          * not covered by mft records, this implies that the
1646                          * next records are all free, so we already have found
1647                          * a free record.
1648                          */
1649                         bit = nr_mft_records;
1650                         if (bit < 24UL)
1651                                 bit = 24UL;
1652                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Found free "
1653                                         "record bit (#1) = 0x%lx.\n", bit);
1654                         goto found_free_rec;
1655                 }
1656                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Done pass 2.\n");
1657                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
1658                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1659                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1660                                 bmp->size, bmp->initialized);
1661                 /* Need to extend the mft bitmap. */
1662                 if (bmp->initialized + 8LL > bmp->allocated) {
1663                         ntfs_io io2;
1664
1665                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Initialized "
1666                                         "> allocated.\n");
1667                         /* Need to extend bitmap by one more cluster. */
1668                         rl = bmp->d.r.runlist;
1669                         rlen = bmp->d.r.len - 1;
1670                         lcn = rl[rlen].lcn + rl[rlen].len;
1671                         io2.fn_put = ntfs_put;
1672                         io2.fn_get = ntfs_get;
1673                         io2.param = &b;
1674                         io2.size = 1;
1675                         io2.do_read = 1;
1676                         err = ntfs_readwrite_attr(vol->bitmap, data, lcn >> 3,
1677                                         &io2);
1678                         if (err)
1679                                 goto err_ret;
1680                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Read %lu "
1681                                         "bytes.\n", (unsigned long)io2.size);
1682                         if (io2.size == 1 && b != 0xff) {
1683                                 __u8 tb = 1 << (lcn & (ntfs_cluster_t)7);
1684                                 if (!(b & tb)) {
1685                                         /* Next cluster is free. Allocate it. */
1686                                         b |= tb;
1687                                         io2.param = &b;
1688                                         io2.do_read = 0;
1689                                         err = ntfs_readwrite_attr(vol->bitmap,
1690                                                         data, lcn >> 3, &io2);
1691                                         if (err || io.size != 1) {
1692                                                 if (!err)
1693                                                         err = -EIO;
1694                                                 goto err_ret;
1695                                         }
1696 append_mftbmp_simple:                   rl[rlen].len++;
1697                                         have_allocated_mftbmp |= 1;
1698                                         ntfs_debug(DEBUG_OTHER, __FUNCTION__
1699                                                         "(): Appending one "
1700                                                         "cluster to mftbmp.\n");
1701                                 }
1702                         }
1703                         if (!have_allocated_mftbmp) {
1704                                 /* Allocate a cluster from the DATA_ZONE. */
1705                                 ntfs_cluster_t lcn2 = lcn;
1706                                 ntfs_cluster_t count = 1;
1707                                 err = ntfs_allocate_clusters(vol, &lcn2,
1708                                                 &count, &rl2, &r2len,
1709                                                 DATA_ZONE);
1710                                 if (err)
1711                                         goto err_ret;
1712                                 if (count != 1 || lcn2 <= 0) {
1713                                         if (count > 0) {
1714 rl2_dealloc_err_out:                            if (ntfs_deallocate_clusters(
1715                                                         vol, rl2, r2len))
1716                                                         ntfs_error(__FUNCTION__
1717                                                         "(): Cluster "
1718                                                         "deallocation in error "
1719                                                         "code path failed! You "
1720                                                         "should run chkdsk.\n");
1721                                         }
1722                                         ntfs_vfree(rl2);
1723                                         if (!err)
1724                                                 err = -EINVAL;
1725                                         goto err_ret;
1726                                 }
1727                                 if (lcn2 == lcn) {
1728                                         ntfs_vfree(rl2);
1729                                         goto append_mftbmp_simple;
1730                                 }
1731                                 /* We need to append a new run. */
1732                                 rl_size = (rlen * sizeof(ntfs_runlist) +
1733                                                 PAGE_SIZE - 1) & PAGE_MASK;
1734                                 /* Reallocate memory if necessary. */
1735                                 if ((rlen + 2) * sizeof(ntfs_runlist) >=
1736                                                 rl_size) {
1737                                         ntfs_runlist *rlt;
1738
1739                                         rl_size += PAGE_SIZE;
1740                                         rlt = ntfs_vmalloc(rl_size);
1741                                         if (!rlt) {
1742                                                 err = -ENOMEM;
1743                                                 goto rl2_dealloc_err_out;
1744                                         }
1745                                         ntfs_memcpy(rlt, rl, rl_size -
1746                                                         PAGE_SIZE);
1747                                         ntfs_vfree(rl);
1748                                         bmp->d.r.runlist = rl = rlt;
1749                                 }
1750                                 ntfs_vfree(rl2);
1751                                 rl[rlen].lcn = lcn = lcn2;
1752                                 rl[rlen].len = count;
1753                                 bmp->d.r.len = ++rlen;
1754                                 have_allocated_mftbmp |= 2;
1755                                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
1756                                                 "Adding run to mftbmp. "
1757                                                 "LCN = %i, len = %i\n", lcn,
1758                                                 count);
1759                         }
1760                         /*
1761                          * We now have extended the mft bitmap allocated size
1762                          * by one cluster. Reflect this in the attribute.
1763                          */
1764                         bmp->allocated += (__s64)vol->cluster_size;
1765                 }
1766                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
1767                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1768                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1769                                 bmp->size, bmp->initialized);
1770                 /* We now have sufficient allocated space. */
1771                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Now have sufficient "
1772                                 "allocated space in mftbmp.\n");
1773                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
1774                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1775                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1776                                 bmp->size, bmp->initialized);
1777                 buf_pos = bmp->initialized;
1778                 bmp->initialized += 8LL;
1779                 if (bmp->initialized > bmp->size)
1780                         bmp->size = bmp->initialized;
1781                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
1782                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1783                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1784                                 bmp->size, bmp->initialized);
1785                 have_allocated_mftbmp |= 4;
1786                 /* Update the mft bitmap attribute value. */
1787                 memset(buf, 0, 8);
1788                 io.param = buf;
1789                 io.size = 8;
1790                 io.do_read = 0;
1791                 err = ntfs_readwrite_attr(vol->mft_ino, bmp, buf_pos, &io);
1792                 if (err || io.size != 8) {
1793                         if (!err)
1794                                 err = -EIO;
1795                         goto shrink_mftbmp_err_ret;
1796                 }
1797                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Wrote extended "
1798                                 "mftbmp bytes %lu.\n", (unsigned long)io.size);
1799                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After write: "
1800                                 "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1801                                 "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1802                                 bmp->size, bmp->initialized);
1803                 bit = buf_pos << 3;
1804                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Found free record "
1805                                 "bit (#2) = 0x%lx.\n", bit);
1806                 goto found_free_rec;
1807         }
1808 found_free_rec:
1809         /* bit is the found free mft record. Allocate it in the mft bitmap. */
1810         vol->mft_data_pos = bit;
1811         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At found_free_rec.\n");
1812         io.param = buf;
1813         io.size = 1;
1814         io.do_read = 1;
1815         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before update: "
1816                         "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1817                         "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1818                         bmp->size, bmp->initialized);
1819         err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
1820         if (err || io.size != 1) {
1821                 if (!err)
1822                         err = -EIO;
1823                 goto shrink_mftbmp_err_ret;
1824         }
1825         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Read %lu bytes.\n",
1826                         (unsigned long)io.size);
1827 #ifdef DEBUG
1828         /* Check our bit is really zero! */
1829         if (*buf & (1 << (bit & 7)))
1830                 BUG();
1831 #endif
1832         *buf |= 1 << (bit & 7);
1833         io.param = buf;
1834         io.do_read = 0;
1835         err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
1836         if (err || io.size != 1) {
1837                 if (!err)
1838                         err = -EIO;
1839                 goto shrink_mftbmp_err_ret;
1840         }
1841         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Wrote %lu bytes.\n",
1842                         (unsigned long)io.size);
1843         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After update: "
1844                         "bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
1845                         "bmp->initialized = 0x%Lx.\n", bmp->allocated,
1846                         bmp->size, bmp->initialized);
1847         /* The mft bitmap is now uptodate. Deal with mft data attribute now. */
1848         ll = (__s64)(bit + 1) << vol->mft_record_size_bits;
1849         if (ll <= data->initialized) {
1850                 /* The allocated record is already initialized. We are done! */
1851                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated mft record "
1852                                 "already initialized!\n");
1853                 goto done_ret;
1854         }
1855         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated mft record needs "
1856                         "to be initialized.\n");
1857         /* The mft record is outside the initialized data. */
1858         mft_rec_size = (unsigned long)vol->mft_record_size;
1859         /* Preserve old values for undo purposes. */
1860         old_data_allocated = data->allocated;
1861         old_data_rlen = data->d.r.len - 1;
1862         old_data_len = data->d.r.runlist[old_data_rlen].len;
1863         /*
1864          * If necessary, extend the mft until it covers the allocated record.
1865          * The loop is only actually used when a freshly formatted volume is
1866          * first written to. But it optimizes away nicely in the common case.
1867          */
1868         while (ll > data->allocated) {
1869                 ntfs_cluster_t lcn2, nr_lcn2, nr, min_nr;
1870
1871                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Extending mft "
1872                                 "data allocation, data->allocated = 0x%Lx, "
1873                                 "data->size = 0x%Lx, data->initialized = "
1874                                 "0x%Lx.\n", data->allocated, data->size,
1875                                 data->initialized);
1876                 /* Minimum allocation is one mft record worth of clusters. */
1877                 if (mft_rec_size <= vol->cluster_size)
1878                         min_nr = (ntfs_cluster_t)1;
1879                 else
1880                         min_nr = mft_rec_size >> vol->cluster_size_bits;
1881                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): min_nr = %i.\n",
1882                                 min_nr);
1883                 /* Allocate 16 mft records worth of clusters. */
1884                 nr = mft_rec_size << 4 >> vol->cluster_size_bits;
1885                 if (!nr)
1886                         nr = (ntfs_cluster_t)1;
1887                 /* Determine the preferred allocation location. */
1888                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): nr = %i.\n", nr);
1889                 rl2 = data->d.r.runlist;
1890                 r2len = data->d.r.len;
1891                 lcn2 = rl2[r2len - 1].lcn + rl2[r2len - 1].len;
1892                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rl2[r2len - 1].lcn "
1893                                 "= %i, .len = %i.\n", rl2[r2len - 1].lcn,
1894                                 rl2[r2len - 1].len);
1895                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): lcn2 = %i, r2len = "
1896                                 "%i.\n", lcn2, r2len);
1897 retry_mft_data_allocation:
1898                 nr_lcn2 = nr;
1899                 err = ntfs_allocate_clusters(vol, &lcn2, &nr_lcn2, &rl2,
1900                                 &r2len, MFT_ZONE);
1901 #ifdef DEBUG
1902                 if (!err && nr_lcn2 < min_nr)
1903                         /* Allocated less than minimum needed. Weird! */
1904                         BUG();
1905 #endif
1906                 if (err) {
1907                         /*
1908                          * If there isn't enough space to do the wanted
1909                          * allocation, but there is enough space to do a
1910                          * minimal allocation, then try that, unless the wanted
1911                          * allocation was already the minimal allocation.
1912                          */
1913                         if (err == -ENOSPC && nr > min_nr &&
1914                                         nr_lcn2 >= min_nr) {
1915                                 nr = min_nr;
1916                                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
1917                                                 "Retrying mft data "
1918                                                 "allocation, nr = min_nr = %i"
1919                                                 ".\n", nr);
1920                                 goto retry_mft_data_allocation;
1921                         }
1922                         goto undo_mftbmp_alloc_err_ret;
1923                 }
1924                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated %i "
1925                                 "clusters starting at LCN %i.\n", nr_lcn2,
1926                                 lcn2);
1927                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated "
1928                                 "runlist:\n");
1929                 dump_runlist(rl2, r2len);
1930                 /* Append rl2 to the mft data attribute's run list. */
1931                 err = splice_runlists(&data->d.r.runlist, (int*)&data->d.r.len,
1932                                 rl2, r2len);
1933                 if (err) {
1934                         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
1935                                         "splice_runlists failed with error "
1936                                         "code %i.\n", -err);
1937                         goto undo_partial_data_alloc_err_ret;
1938                 }
1939                 /* Reflect the allocated clusters in the mft allocated data. */
1940                 data->allocated += nr_lcn2 << vol->cluster_size_bits;
1941                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After extending mft "
1942                                 "data allocation, data->allocated = 0x%Lx, "
1943                                 "data->size = 0x%Lx, data->initialized = "
1944                                 "0x%Lx.\n", data->allocated, data->size,
1945                                 data->initialized);
1946         }
1947         /* Prepare a formatted (empty) mft record. */
1948         memset(buf, 0, mft_rec_size);
1949         ntfs_fill_mft_header(buf, mft_rec_size, 0, 0, 0);
1950         err = ntfs_insert_fixups(buf, mft_rec_size);
1951         if (err)
1952                 goto undo_data_alloc_err_ret;
1953         /*
1954          * Extend mft data initialized size to reach the allocated mft record
1955          * and write the formatted mft record buffer to each mft record being
1956          * initialized. Note, that ntfs_readwrite_attr extends both
1957          * data->initialized and data->size, so no need for us to touch them.
1958          */
1959         old_data_initialized = data->initialized;
1960         old_data_size = data->size;
1961         while (ll > data->initialized) {
1962                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Initializing mft "
1963                                 "record 0x%Lx.\n",
1964                                 data->initialized >> vol->mft_record_size_bits);
1965                 io.param = buf;
1966                 io.size = mft_rec_size;
1967                 io.do_read = 0;
1968                 err = ntfs_readwrite_attr(vol->mft_ino, data,
1969                                 data->initialized, &io);
1970                 if (err || io.size != mft_rec_size) {
1971                         if (!err)
1972                                 err = -EIO;
1973                         goto undo_data_init_err_ret;
1974                 }
1975                 ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Wrote %i bytes to "
1976                                 "mft data.\n", io.size);
1977         }
1978         /* Update the VFS inode size as well. */
1979         VFS_I(vol->mft_ino)->i_size = data->size;
1980 #ifdef DEBUG
1981         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After mft record "
1982                         "initialization: data->allocated = 0x%Lx, data->size "
1983                         "= 0x%Lx, data->initialized = 0x%Lx.\n",
1984                         data->allocated, data->size, data->initialized);
1985         /* Sanity checks. */
1986         if (data->size > data->allocated || data->size < data->initialized ||
1987                         data->initialized > data->allocated)
1988                 BUG();
1989 #endif
1990 done_ret:
1991         /* Return the number of the allocated mft record. */
1992         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At done_ret. *result = bit = "
1993                         "0x%lx.\n", bit);
1994         *result = bit;
1995         vol->mft_data_pos = bit + 1;
1996 err_ret:
1997         unlock_kernel();
1998         free_page((unsigned long)buf);
1999         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Syncing inode $MFT.\n");
2000         if (ntfs_update_inode(vol->mft_ino))
2001                 ntfs_error(__FUNCTION__ "(): Failed to sync inode $MFT. "
2002                                 "Continuing anyway.\n");
2003         if (!err) {
2004                 ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): Done. Allocated mft "
2005                                 "record number *result = 0x%lx.\n", *result);
2006                 return 0;
2007         }
2008         if (err != -ENOSPC)
2009                 ntfs_error(__FUNCTION__ "(): Failed to allocate an mft "
2010                                 "record. Returning error code %i.\n", -err);
2011         else
2012                 ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): Failed to allocate "
2013                                 "an mft record due to lack of free space.\n");
2014         return err;
2015 undo_data_init_err_ret:
2016         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At "
2017                         "undo_data_init_err_ret.\n");
2018         data->initialized = old_data_initialized;
2019         data->size = old_data_size;
2020 undo_data_alloc_err_ret:
2021         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At undo_data_alloc_err_ret."
2022                         "\n");
2023         data->allocated = old_data_allocated;
2024 undo_partial_data_alloc_err_ret:
2025         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At "
2026                         "undo_partial_data_alloc_err_ret.\n");
2027         /* Deallocate the clusters. */
2028         if (ntfs_deallocate_clusters(vol, rl2, r2len))
2029                 ntfs_error(__FUNCTION__ "(): Error deallocating clusters in "
2030                                 "error code path. You should run chkdsk.\n");
2031         ntfs_vfree(rl2);
2032         /* Revert the run list back to what it was before. */
2033         r2len = data->d.r.len;
2034         rl2 = data->d.r.runlist;
2035         rl2[old_data_rlen++].len = old_data_len;
2036         rl2[old_data_rlen].lcn = (ntfs_cluster_t)-1;
2037         rl2[old_data_rlen].len = (ntfs_cluster_t)0;
2038         data->d.r.len = old_data_rlen;
2039         rl2_size = ((old_data_rlen + 1) * sizeof(ntfs_runlist) + PAGE_SIZE -
2040                         1) & PAGE_MASK;
2041         /* Reallocate memory freeing any extra memory allocated. */
2042         if (rl2_size < ((r2len * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
2043                         PAGE_MASK)) {
2044                 rl2 = ntfs_vmalloc(rl2_size);
2045                 if (rl2) {
2046                         ntfs_memcpy(rl2, data->d.r.runlist, rl2_size);
2047                         ntfs_vfree(data->d.r.runlist);
2048                         data->d.r.runlist = rl2;
2049                 } else
2050                         ntfs_error(__FUNCTION__ "(): Error reallocating "
2051                                         "memory in error code path. This "
2052                                         "should be harmless.\n");
2053         }
2054 undo_mftbmp_alloc_err_ret:
2055         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At "
2056                         "undo_mftbmp_alloc_err_ret.\n");
2057         /* Deallocate the allocated bit in the mft bitmap. */
2058         io.param = buf;
2059         io.size = 1;
2060         io.do_read = 1;
2061         err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
2062         if (!err && io.size == 1) {
2063                 *buf &= ~(1 << (bit & 7));
2064                 io.param = buf;
2065                 io.do_read = 0;
2066                 err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
2067         }
2068         if (err || io.size != 1) {
2069                 if (!err)
2070                         err = -EIO;
2071                 ntfs_error(__FUNCTION__ "(): Error deallocating mft record in "
2072                                 "error code path. You should run chkdsk.\n");
2073         }
2074 shrink_mftbmp_err_ret:
2075         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At shrink_mftbmp_err_ret.\n");
2076         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): have_allocated_mftbmp = "
2077                         "%i.\n", have_allocated_mftbmp);
2078         if (!have_allocated_mftbmp)
2079                 goto err_ret;
2080         /* Shrink the mftbmp back to previous size. */
2081         if (bmp->size == bmp->initialized)
2082                 bmp->size -= 8LL;
2083         bmp->initialized -= 8LL;
2084         have_allocated_mftbmp &= ~4;
2085         /* If no allocation occured then we are done. */
2086         ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): have_allocated_mftbmp = "
2087                         "%i.\n", have_allocated_mftbmp);
2088         if (!have_allocated_mftbmp)
2089                 goto err_ret;
2090         /* Deallocate the allocated cluster. */
2091         bmp->allocated -= (__s64)vol->cluster_size;
2092         if (ntfs_deallocate_cluster_run(vol, lcn, (ntfs_cluster_t)1))
2093                 ntfs_error(__FUNCTION__ "(): Error deallocating cluster in "
2094                                 "error code path. You should run chkdsk.\n");
2095         switch (have_allocated_mftbmp & 3) {
2096         case 1:
2097                 /* Delete the last lcn from the last run of mftbmp. */
2098                 rl[rlen - 1].len--;
2099                 break;
2100         case 2:
2101                 /* Delete the last run of mftbmp. */
2102                 bmp->d.r.len = --rlen;
2103                 /* Reallocate memory if necessary. */
2104                 if ((rlen + 1) * sizeof(ntfs_runlist) <= rl_size - PAGE_SIZE) {
2105                         ntfs_runlist *rlt;
2106
2107                         rl_size -= PAGE_SIZE;
2108                         rlt = ntfs_vmalloc(rl_size);
2109                         if (rlt) {
2110                                 ntfs_memcpy(rlt, rl, rl_size);
2111                                 ntfs_vfree(rl);
2112                                 bmp->d.r.runlist = rl = rlt;
2113                         } else
2114                                 ntfs_error(__FUNCTION__ "(): Error "
2115                                                 "reallocating memory in error "
2116                                                 "code path. This should be "
2117                                                 "harmless.\n");
2118                 }
2119                 bmp->d.r.runlist[bmp->d.r.len].lcn = (ntfs_cluster_t)-1;
2120                 bmp->d.r.runlist[bmp->d.r.len].len = (ntfs_cluster_t)0;
2121                 break;
2122         default:
2123                 BUG();
2124         }
2125         goto err_ret;
2126 }
2127
2128 /* We need 0x48 bytes in total. */
2129 static int add_standard_information(ntfs_inode *ino)
2130 {
2131         ntfs_time64_t now;
2132         char data[0x30];
2133         char *position = data;
2134         ntfs_attribute *si;
2135
2136         now = ntfs_now();
2137         NTFS_PUTU64(position + 0x00, now);              /* File creation */
2138         NTFS_PUTU64(position + 0x08, now);              /* Last modification */
2139         NTFS_PUTU64(position + 0x10, now);              /* Last mod for MFT */
2140         NTFS_PUTU64(position + 0x18, now);              /* Last access */
2141         NTFS_PUTU64(position + 0x20, 0);                /* MSDOS file perms */
2142         NTFS_PUTU64(position + 0x28, 0);                /* unknown */
2143         return ntfs_create_attr(ino, ino->vol->at_standard_information, 0,
2144                         data, sizeof(data), &si);
2145 }
2146
2147 static int add_filename(ntfs_inode *ino, ntfs_inode *dir,
2148                 const unsigned char *filename, int length, ntfs_u32 flags)
2149 {
2150         unsigned char *position;
2151         unsigned int size;
2152         ntfs_time64_t now;
2153         int count, error;
2154         unsigned char* data;
2155         ntfs_attribute *fn;
2156
2157         /* Work out the size. */
2158         size = 0x42 + 2 * length;
2159         data = ntfs_malloc(size);
2160         if (!data)
2161                 return -ENOMEM;
2162         /* Search for a position. */
2163         position = data;
2164         NTFS_PUTINUM(position, dir);                    /* Inode num of dir */
2165         now = ntfs_now();
2166         NTFS_PUTU64(position + 0x08, now);              /* File creation */
2167         NTFS_PUTU64(position + 0x10, now);              /* Last modification */
2168         NTFS_PUTU64(position + 0x18, now);              /* Last mod for MFT */
2169         NTFS_PUTU64(position + 0x20, now);              /* Last access */
2170         /* FIXME: Get the following two sizes by finding the data attribute
2171          * in ino->attr and copying the corresponding fields from there.
2172          * If no data present then set to zero. In current implementation
2173          * add_data is called after add_filename so zero is correct on
2174          * creation. Need to change when we have hard links / support different
2175          * filename namespaces. (AIA) */
2176         NTFS_PUTS64(position + 0x28, 0);                /* Allocated size */
2177         NTFS_PUTS64(position + 0x30, 0);                /* Data size */
2178         NTFS_PUTU32(position + 0x38, flags);            /* File flags */
2179         NTFS_PUTU32(position + 0x3c, 0);                /* We don't use these
2180                                                          * features yet. */
2181         NTFS_PUTU8(position + 0x40, length);            /* Filename length */
2182         NTFS_PUTU8(position + 0x41, 0);                 /* Only long name */
2183                 /* FIXME: This is madness. We are defining the POSIX namespace
2184                  * for the filename here which can mean that the file will be
2185                  * invisible when in Windows NT/2k! )-: (AIA) */
2186         position += 0x42;
2187         for (count = 0; count < length; count++) {
2188                 NTFS_PUTU16(position + 2 * count, filename[count]);
2189         }
2190         error = ntfs_create_attr(ino, ino->vol->at_file_name, 0, data, size,
2191                                  &fn);
2192         if (!error)
2193                 error = ntfs_dir_add(dir, ino, fn);
2194         ntfs_free(data);
2195         return error;
2196 }
2197
2198 int add_security(ntfs_inode* ino, ntfs_inode* dir)
2199 {
2200         int error;
2201         char *buf;
2202         int size;
2203         ntfs_attribute* attr;
2204         ntfs_io io;
2205         ntfs_attribute *se;
2206
2207         attr = ntfs_find_attr(dir, ino->vol->at_security_descriptor, 0);
2208         if (!attr)
2209                 return -EOPNOTSUPP; /* Need security in directory. */
2210         size = attr->size;
2211         if (size > 512)
2212                 return -EOPNOTSUPP;
2213         buf = ntfs_malloc(size);
2214         if (!buf)
2215                 return -ENOMEM;
2216         io.fn_get = ntfs_get;
2217         io.fn_put = ntfs_put;
2218         io.param = buf;
2219         io.size = size;
2220         error = ntfs_read_attr(dir, ino->vol->at_security_descriptor, 0, 0,&io);
2221         if (!error && io.size != size)
2222                 ntfs_error("wrong size in add_security\n");
2223         if (error) {
2224                 ntfs_free(buf);
2225                 return error;
2226         }
2227         /* FIXME: Consider ACL inheritance. */
2228         error = ntfs_create_attr(ino, ino->vol->at_security_descriptor,
2229                                  0, buf, size, &se);
2230         ntfs_free(buf);
2231         return error;
2232 }
2233
2234 static int add_data(ntfs_inode* ino, unsigned char *data, int length)
2235 {
2236         ntfs_attribute *da;
2237
2238         return ntfs_create_attr(ino, ino->vol->at_data, 0, data, length, &da);
2239 }
2240
2241 /*
2242  * We _could_ use 'dir' to help optimise inode allocation.
2243  *
2244  * FIXME: Need to undo what we do in ntfs_alloc_mft_record if we get an error
2245  * further on in ntfs_alloc_inode. Either fold the two functions to allow
2246  * proper undo or just deallocate the record from the mft bitmap. (AIA)
2247  */
2248 int ntfs_alloc_inode(ntfs_inode *dir, ntfs_inode *result, const char *filename,
2249                 int namelen, ntfs_u32 flags)
2250 {
2251         ntfs_volume *vol = dir->vol;
2252         int err;
2253         ntfs_u8 buffer[2];
2254         ntfs_io io;
2255
2256         err = ntfs_alloc_mft_record(vol, &(result->i_number));
2257         if (err) {
2258                 if (err == -ENOSPC)
2259                         ntfs_error(__FUNCTION__ "(): No free inodes.\n");
2260                 return err;
2261         }
2262         /* Get the sequence number. */
2263         io.fn_put = ntfs_put;
2264         io.fn_get = ntfs_get;
2265         io.param = buffer;
2266         io.size = 2;
2267         err = ntfs_read_attr(vol->mft_ino, vol->at_data, 0,
2268                         ((__s64)result->i_number << vol->mft_record_size_bits)
2269                         + 0x10, &io);
2270         // FIXME: We are leaving the MFT in inconsistent state! (AIA)
2271         if (err)
2272                 return err;
2273         /* Increment the sequence number skipping zero. */
2274         result->sequence_number = (NTFS_GETU16(buffer) + 1) & 0xffff;
2275         if (!result->sequence_number)
2276                 result->sequence_number++;
2277         result->vol = vol;
2278         result->attr_count = 0;
2279         result->attrs = 0;
2280         result->record_count = 1;
2281         result->records = ntfs_calloc(8 * sizeof(int));
2282         if (!result->records)
2283                 goto mem_err_out;
2284         result->records[0] = result->i_number;
2285         result->attr = ntfs_calloc(vol->mft_record_size);
2286         if (!result->attr) {
2287                 ntfs_free(result->records);
2288                 result->records = NULL;
2289                 goto mem_err_out;
2290         }
2291         ntfs_fill_mft_header(result->attr, vol->mft_record_size,
2292                         result->sequence_number, 1, 1);
2293         err = add_standard_information(result);
2294         if (!err)
2295                 err = add_filename(result, dir, filename, namelen, flags);
2296         if (!err)
2297                 err = add_security(result, dir);
2298         // FIXME: We are leaving the MFT in inconsistent state on error! (AIA)
2299         return err;
2300 mem_err_out:
2301         // FIXME: We are leaving the MFT in inconsistent state! (AIA)
2302         result->record_count = 0;
2303         result->attr = NULL;
2304         return -ENOMEM;
2305 }
2306
2307 int ntfs_alloc_file(ntfs_inode *dir, ntfs_inode *result, char *filename,
2308                 int namelen)
2309 {
2310         int err;
2311
2312         err = ntfs_alloc_inode(dir, result, filename, namelen, 0);
2313         if (!err)
2314                 err = add_data(result, 0, 0);
2315         return err;
2316 }
2317