开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
inode.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：72k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

inode.c：源码内容
  1. /*
  2.  * inode.c
  3.  *
  4.  * Copyright (C) 1995-1999 Martin von L鰓is
  5.  * Copyright (C) 1996 Albert D. Cahalan
  6.  * Copyright (C) 1996-1997 R間is 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>
  25. typedef struct {
  26. int recno;
  27. unsigned char *record;
  28. } ntfs_mft_record;
  30. typedef struct {
  31. int size;
  32. int count;
  33. ntfs_mft_record *records;
  34. } ntfs_disk_inode;
  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;
  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. }
  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;
  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. }
  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;
  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;
  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. }
  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;
  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;
  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. }
  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;
  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. "failedn", 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) failedn", 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. "failedn", 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) failedn", 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. }
  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;
  387. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 1n", 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 2n", ino->i_number);
  391. alist = ntfs_find_attr(ino, vol->at_attribute_list, 0);
  392. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 3n", ino->i_number);
  393. if (!alist)
  394. return;
  395. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 4n", ino->i_number);
  396. datasize = alist->size;
  397. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: alist->size = 0x%xn",
  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 5n", 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;
  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 = %in",
  418. ino->i_number, len);
  419. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: delta = %in",
  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_attributesn");
  425. delta += len;
  426. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: after += len, "
  427. "delta = %in", ino->i_number, delta);
  428. parse_attributes(ino, buf, &delta);
  429. ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: after "
  430. "parse_attr, delta = %in", 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 6n", ino->i_number);
  437. ntfs_free(buf);
  438. }
  440. int ntfs_init_inode(ntfs_inode *ino, ntfs_volume *vol, int inum)
  441. {
  442. char *buf;
  443. int error;
  445. ntfs_debug(DEBUG_FILE1, "Initializing inode 0x%xn", 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 failedn", inum);
  454. return error;
  455. }
  456. ntfs_debug(DEBUG_FILE2, "Init inode: got mft 0x%xn", 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%xn", inum);
  464. return 0;
  465. }
  467. void ntfs_clear_inode(ntfs_inode *ino)
  468. {
  469. int i;
  470. if (!ino->attr) {
  471. ntfs_error("ntfs_clear_inode: double freen");
  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. }
  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. }
  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. }
  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;
  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. }
  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. }
  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. }
  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%xn", type);
  603. return -1;
  604. }
  605. // ntfs_debug(DEBUG_FILE3, "ntfs_decompress_run: length = 0x%xn",*length);
  606. if (*length < 0)
  607. {
  608. ntfs_error("Negative run length decodedn");
  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%xn", type);
  644. return -1;
  645. }
  646. // ntfs_debug(DEBUG_FILE3, "ntfs_decompress_run: cluster = 0x%xn",
  647. // *cluster);
  648. *data += (type >> 4);
  649. return 0;
  650. }
  652. static void dump_runlist(const ntfs_runlist *rl, const int rlen);
  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;
  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. }
  788. int ntfs_read_attr(ntfs_inode *ino, int type, char *name, __s64 offset,
  789.    ntfs_io *buf)
  790. {
  791. ntfs_attribute *attr;
  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%xn", type, ino->i_number);
  798. return -EINVAL;
  799. }
  800. return ntfs_readwrite_attr(ino, attr, offset, buf);
  801. }
  803. int ntfs_write_attr(ntfs_inode *ino, int type, char *name, __s64 offset,
  804.     ntfs_io *buf)
  805. {
  806. ntfs_attribute *attr;
  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%xn", type, ino->i_number);
  813. return -EINVAL;
  814. }
  815. return ntfs_readwrite_attr(ino, attr, offset, buf);
  816. }
  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;
  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. }
  840. static int allocate_store(ntfs_volume *vol, ntfs_disk_inode *store, int count)
  841. {
  842. int i;
  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. }
  868. static void deallocate_store(ntfs_disk_inode* store)
  869. {
  870. int i;
  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. }
  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. }
  998. static void count_runs(ntfs_attribute *attr, char *buf)
  999. {
  1000. ntfs_u32 first, count, last, i;
  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. } 
  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;
  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;
  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. }
  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;
  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. }
  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;
  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%xn", ino->i_number);
  1214. deallocate_store(&store);
  1215. return error ? error : -EIO;
  1216. }
  1217. }
  1218. deallocate_store(&store);
  1219. return 0;
  1220. }
  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;
  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 decompressn");
  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 decompressn");
  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. }
  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. }
  1309. static __inline__ void ntfs_set_bit(unsigned char *byte, const int bit)
  1310. {
  1311. byte[bit >> 3] |= 1 << (bit & 7);
  1312. }
  1314. static __inline__ void ntfs_clear_bit(unsigned char *byte, const int bit)
  1315. {
  1316. byte[bit >> 3] &= ~(1 << (bit & 7));
  1317. }
  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. }
  1329. static void dump_runlist(const ntfs_runlist *rl, const int rlen)
  1330. {
  1331. #ifdef DEBUG
  1332. int i;
  1333. ntfs_cluster_t ct;
  1335. ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rlen = %i.n", rlen);
  1336. ntfs_debug(DEBUG_OTHER, "VCN        LCN        Run lengthn");
  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%sn", 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. }
  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;
  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. }
  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;
  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 = %lun", 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;
  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;
  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 = %in", 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;
  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;
  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. }
  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;
  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. }
  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;
  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. }
  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;
  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_securityn");
  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. }
  2234. static int add_data(ntfs_inode* ino, unsigned char *data, int length)
  2235. {
  2236. ntfs_attribute *da;
  2238. return ntfs_create_attr(ino, ino->vol->at_data, 0, data, length, &da);
  2239. }
  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;
  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. }
  2307. int ntfs_alloc_file(ntfs_inode *dir, ntfs_inode *result, char *filename,
  2308. int namelen)
  2309. {
  2310. int err;
  2312. err = ntfs_alloc_inode(dir, result, filename, namelen, 0);
  2313. if (!err)
  2314. err = add_data(result, 0, 0);
  2315. return err;
  2316. }