| blob | a6ab9d64ea1b32777fa79a42f6396f9f52bcab08 |
1 /*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
5 #include <linux/time.h>
6 #include <linux/fs.h>
10 #include <linux/exportfs.h>
11 #include <linux/pagemap.h>
12 #include <linux/highmem.h>
13 #include <linux/slab.h>
14 #include <linux/uaccess.h>
15 #include <asm/unaligned.h>
16 #include <linux/buffer_head.h>
17 #include <linux/mpage.h>
18 #include <linux/writeback.h>
19 #include <linux/quotaops.h>
20 #include <linux/swap.h>
21 #include <linux/uio.h>
22 #include <linux/bio.h>
28 {
29 /*
30 * We need blocks for transaction + (user+group) quota
31 * update (possibly delete)
32 */
46 /*
47 * The = 0 happens when we abort creating a new inode
48 * for some reason like lack of space..
49 * also handles bad_inode case
50 */
65 /*
66 * Do quota update inside a transaction for journaled quotas.
67 * We must do that after delete_object so that quota updates
68 * go into the same transaction as stat data deletion
69 */
74 }
79 /*
80 * check return value from reiserfs_delete_object after
81 * ending the transaction
82 */
86 /*
87 * all items of file are deleted, so we can remove
88 * "save" link
89 * we can't do anything about an error here
90 */
92 out:
95 /* no object items are in the tree */
96 ;
97 }
99 /* note this must go after the journal_end to prevent deadlock */
106 no_delete:
109 }
113 {
121 }
123 /*
124 * take base of inode_key (it comes from inode always) (dirid, objectid)
125 * and version from an inode, set offset and type of key
126 */
129 {
133 length);
134 }
136 /* when key is 0, do not set version and short key */
141 {
146 }
151 /* set_ih_free_space (ih, 0); */
152 /*
153 * for directory items it is entry count, for directs and stat
154 * datas - 0xffff, for indirects - 0
155 */
157 }
159 /*
160 * FIXME: we might cache recently accessed indirect item
161 * Ugh. Not too eager for that....
162 * I cut the code until such time as I see a convincing argument (benchmark).
163 * I don't want a bloated inode struct..., and I don't like code complexity....
164 */
166 /*
167 * cutting the code is fine, since it really isn't in use yet and is easy
168 * to add back in. But, Vladimir has a really good idea here. Think
169 * about what happens for reading a file. For each page,
170 * The VFS layer calls reiserfs_readpage, who searches the tree to find
171 * an indirect item. This indirect item has X number of pointers, where
172 * X is a big number if we've done the block allocation right. But,
173 * we only use one or two of these pointers during each call to readpage,
174 * needlessly researching again later on.
175 *
176 * The size of the cache could be dynamic based on the size of the file.
177 *
178 * I'd also like to see us cache the location the stat data item, since
179 * we are needlessly researching for that frequently.
180 *
181 * --chris
182 */
184 /*
185 * If this page has a file tail in it, and
186 * it was read in by get_block_create_0, the page data is valid,
187 * but tail is still sitting in a direct item, and we can't write to
188 * it. So, look through this page, and check all the mapped buffers
189 * to make sure they have valid block numbers. Any that don't need
190 * to be unmapped, so that __block_write_begin will correctly call
191 * reiserfs_get_block to convert the tail into an unformatted node
192 */
194 {
204 }
207 }
208 }
210 /*
211 * reiserfs_get_block does not need to allocate a block only if it has been
212 * done already or non-hole position has been found in the indirect item
213 */
217 {
224 }
227 {
229 }
233 {
235 }
237 /*
238 * files which were created in the earlier version can not be longer,
239 * than 2 gb
240 */
242 {
243 /* it is new file. */
245 /* old file, but 'block' is inside of 2gb */
250 }
254 {
263 /* we cannot restart while nested */
266 }
273 }
275 }
277 /*
278 * it is called by get_block when create == 0. Returns block number
279 * for 'block'-th logical block of file. When it hits direct item it
280 * returns 0 (being called from bmap) or read direct item into piece
281 * of page (bh_result)
282 * Please improve the english/clarity in the comment above, as it is
283 * hard to understand.
284 */
287 {
292 b_blocknr_t blocknr;
300 /* prepare the key to look for the 'block'-th block of file */
312 /*
313 * We do not return -ENOENT if there is a hole but page is
314 * uptodate, because it means that there is some MMAPED data
315 * associated with it that is yet to be written to disk.
316 */
320 }
322 }
329 /*
330 * FIXME: here we could cache indirect item or part of it in
331 * the inode to avoid search_by_key in case of subsequent
332 * access to file
333 */
341 }
343 /*
344 * We do not return -ENOENT if there is a hole but
345 * page is uptodate, because it means that there is
346 * some MMAPED data associated with it that is
347 * yet to be written to disk.
348 */
352 }
358 }
359 /* requested data are in direct item(s) */
361 /*
362 * we are called by bmap. FIXME: we can not map block of file
363 * when it is stored in direct item(s)
364 */
369 }
371 /*
372 * if we've got a direct item, and the buffer or page was uptodate,
373 * we don't want to pull data off disk again. skip to the
374 * end, where we map the buffer and return
375 */
379 /*
380 * grab_tail_page can trigger calls to reiserfs_get_block on
381 * up to date pages without any buffers. If the page is up
382 * to date, we don't want read old data off disk. Set the up
383 * to date bit on the buffer instead and jump to the end
384 */
388 }
389 /* read file tail into part of page */
393 /*
394 * we only want to kmap if we are reading the tail into the page.
395 * this is not the common case, so we don't kmap until we are
396 * sure we need to. But, this means the item might move if
397 * kmap schedules
398 */
407 }
408 /*
409 * make sure we don't read more bytes than actually exist in
410 * the file. This can happen in odd cases where i_size isn't
411 * correct, and when direct item padding results in a few
412 * extra bytes at the end of the direct item
413 */
417 chars =
423 }
431 /*
432 * we done, if read direct item is not the last item of
433 * node FIXME: we could try to check right delimiting key
434 * to see whether direct item continues in the right
435 * neighbor or rely on i_size
436 */
440 /* update key to look for the next piece */
444 /* i/o error most likely */
453 finished:
459 /*
460 * this buffer has valid data, but isn't valid for io. mapping it to
461 * block #0 tells the rest of reiserfs it just has a tail in it
462 */
466 }
468 /*
469 * this is called to create file map. So, _get_block_create_0 will not
470 * read direct item
471 */
474 {
479 /* do not read the direct item */
483 }
485 /*
486 * special version of get_block that is only used by grab_tail_page right
487 * now. It is sent to __block_write_begin, and when you try to get a
488 * block past the end of the file (or a block from a hole) it returns
489 * -ENOENT instead of a valid buffer. __block_write_begin expects to
490 * be able to do i/o on the buffers returned, unless an error value
491 * is also returned.
492 *
493 * So, this allows __block_write_begin to be used for reading a single block
494 * in a page. Where it does not produce a valid page for holes, or past the
495 * end of the file. This turns out to be exactly what we need for reading
496 * tails for conversion.
497 *
498 * The point of the wrapper is forcing a certain value for create, even
499 * though the VFS layer is calling this function with create==1. If you
500 * don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
501 * don't use this function.
502 */
506 {
508 }
510 /*
511 * This is special helper for reiserfs_get_block in case we are executing
512 * direct_IO request.
513 */
515 sector_t iblock,
518 {
523 /*
524 * We set the b_size before reiserfs_get_block call since it is
525 * referenced in convert_tail_for_hole() that may be called from
526 * reiserfs_get_block()
527 */
535 /* don't allow direct io onto tail pages */
537 /*
538 * make sure future calls to the direct io funcs for this
539 * offset in the file fail by unmapping the buffer
540 */
543 }
545 /*
546 * Possible unpacked tail. Flush the data before pages have
547 * disappeared
548 */
561 }
562 out:
564 }
566 /*
567 * helper function for when reiserfs_get_block is called for a hole
568 * but the file tail is still in a direct item
569 * bh_result is the buffer head for the hole
570 * tail_offset is the offset of the start of the tail in the file
571 *
572 * This calls prepare_write, which will start a new transaction
573 * you should not be in a transaction, or have any paths held when you
574 * call this.
575 */
578 loff_t tail_offset)
579 {
590 /* always try to read until the end of the block */
595 /*
596 * hole_page can be zero in case of direct_io, we are sure
597 * that we cannot get here if we write with O_DIRECT into tail page
598 */
604 }
607 }
609 /*
610 * we don't have to make sure the conversion did not happen while
611 * we were locking the page because anyone that could convert
612 * must first take i_mutex.
613 *
614 * We must fix the tail page for writing because it might have buffers
615 * that are mapped, but have a block number of 0. This indicates tail
616 * data that has been read directly into the page, and
617 * __block_write_begin won't trigger a get_block in this case.
618 */
625 /* tail conversion might change the data in the page */
630 unlock:
634 }
635 out:
637 }
640 sector_t block,
644 {
647 #ifdef REISERFS_PREALLOCATE
651 }
652 #endif
654 block);
655 }
659 {
661 /* b_blocknr_t is (unsigned) 32 bit int*/
672 /*
673 * space reserved in transaction batch:
674 * . 3 balancings in direct->indirect conversion
675 * . 1 block involved into reiserfs_update_sd()
676 * XXX in practically impossible worst case direct2indirect()
677 * can incur (much) more than 3 balancings.
678 * quota update for user, group
679 */
685 loff_t new_offset =
694 }
696 /*
697 * if !create, we aren't changing the FS, so we don't need to
698 * log anything, so we don't need to start a transaction
699 */
702 /* find number of block-th logical block of the file */
707 }
709 /*
710 * if we're already in a transaction, make sure to close
711 * any new transactions we start in this func
712 */
717 /*
718 * If file is of such a size, that it might have a tail and
719 * tails are enabled we should mark it as possibly needing
720 * tail packing on close
721 */
728 /* set the key of the first byte in the 'block'-th block of file */
731 start_trans:
736 }
738 }
739 research:
745 }
757 /* we have to allocate block for the unformatted node */
761 }
763 repeat =
767 /*
768 * restart the transaction to give the journal a chance to free
769 * some blocks. releases the path, so we have to go back to
770 * research if we succeed on the second try
771 */
777 repeat =
783 }
786 else
789 }
794 }
795 }
798 b_blocknr_t unfm_ptr;
799 /*
800 * 'block'-th block is in the file already (there is
801 * corresponding cell in some indirect item). But it may be
802 * zero unformatted node pointer (hole)
803 */
806 /* use allocated block to plug the hole */
811 bh);
813 }
822 }
831 /*
832 * the item was found, so new blocks were not added to the file
833 * there is no need to make sure the inode is updated with this
834 * transaction
835 */
837 }
842 }
844 /*
845 * desired position is not found or is in the direct item. We have
846 * to append file with holes up to 'block'-th block converting
847 * direct items to indirect one if necessary
848 */
855 /* indirect item has to be inserted */
860 /*
861 * we are going to add 'block'-th block to the file.
862 * Use allocated block for that
863 */
870 }
875 retval =
881 /*
882 * retval == -ENOSPC, -EDQUOT or -EIO
883 * or -EEXIST
884 */
886 }
888 /* direct item has to be converted */
889 loff_t tail_offset;
891 tail_offset =
895 /*
896 * direct item we just found fits into block we have
897 * to map. Convert it into unformatted node: use
898 * bh_result for the conversion
899 */
906 /*
907 * we have to pad file tail stored in direct
908 * item(s) up to block size and convert it
909 * to unformatted node. FIXME: this should
910 * also get into page cache
911 */
914 /*
915 * ugly, but we can only end the transaction if
916 * we aren't nested
917 */
920 retval =
921 reiserfs_end_persistent_transaction
926 }
928 retval =
930 tail_offset);
935 "convert tail failed "
938 retval);
940 /*
941 * the bitmap, the super,
942 * and the stat data == 3
943 */
948 inode,
949 allocated_block_nr,
951 }
953 }
955 }
956 retval =
958 tail_offset);
964 }
965 /*
966 * it is important the set_buffer_uptodate is done
967 * after the direct2indirect. The buffer might
968 * contain valid data newer than the data on disk
969 * (read by readpage, changed, and then sent here by
970 * writepage). direct2indirect needs to know if unbh
971 * was already up to date, so it can decide if the
972 * data in unbh needs to be replaced with data from
973 * the disk
974 */
977 /*
978 * unbh->b_page == NULL in case of DIRECT_IO request,
979 * this means buffer will disappear shortly, so it
980 * should not be added to
981 */
983 /*
984 * we've converted the tail, so we must
985 * flush unbh before the transaction commits
986 */
989 /*
990 * mark it dirty now to prevent commit_write
991 * from adding this buffer to the inode's
992 * dirty buffer list
993 */
994 /*
995 * AKPM: changed __mark_buffer_dirty to
996 * mark_buffer_dirty(). It's still atomic,
997 * but it sets the page dirty too, which makes
998 * it eligible for writeback at any time by the
999 * VM (which was also the case with
1000 * __mark_buffer_dirty())
1001 */
1003 }
1005 /*
1006 * append indirect item with holes if needed, when
1007 * appending pointer to 'block'-th block use block,
1008 * which is already allocated
1009 */
1011 /*
1012 * We use this in case we need to allocate
1013 * only one block which is a fastpath
1014 */
1017 __u64 max_to_insert =
1019 UNFM_P_SIZE;
1020 __u64 blocks_needed;
1024 /*
1025 * indirect item has to be appended,
1026 * set up key of that position
1027 * (key type is unimportant)
1028 */
1038 blocks_needed =
1042 s_blocksize_bits);
1052 }
1053 }
1055 /*
1056 * we are going to add target block to
1057 * the file. Use allocated block for that
1058 */
1066 /* paste hole to the indirect item */
1067 /*
1068 * If kmalloc failed, max_to_insert becomes
1069 * zero and it means we only have space for
1070 * one block
1071 */
1072 blocks_needed =
1074 }
1075 retval =
1078 UNFM_P_SIZE *
1079 blocks_needed);
1088 }
1090 /*
1091 * We need to mark new file size in case
1092 * this function will be interrupted/aborted
1093 * later on. And we may do this only for
1094 * holes.
1095 */
1098 }
1099 }
1104 /*
1105 * this loop could log more blocks than we had originally
1106 * asked for. So, we have to allow the transaction to end
1107 * if it is too big or too full. Update the inode so things
1108 * are consistent if we crash before the function returns
1109 * release the path so that anybody waiting on the path before
1110 * ending their transaction will be able to continue.
1111 */
1116 }
1117 /*
1118 * inserting indirect pointers for a hole can take a
1119 * long time. reschedule if needed and also release the write
1120 * lock for others.
1121 */
1128 }
1138 }
1147 failure:
1155 }
1160 }
1162 static int
1165 {
1167 }
1169 /*
1170 * Compute real number of used bytes by file
1171 * Following three functions can go away when we'll have enough space in
1172 * stat item
1173 */
1175 {
1182 /*
1183 * End of file is also in full block with indirect reference, so round
1184 * up to the next block.
1185 *
1186 * there is just no way to know if the tail is actually packed
1187 * on the file, so we have to assume it isn't. When we pack the
1188 * tail, we add 4 bytes to pretend there really is an unformatted
1189 * node pointer
1190 */
1191 bytes =
1194 sd_size;
1196 }
1200 {
1204 }
1207 }
1209 /* Compute number of blocks used by file in ReiserFS counting */
1211 {
1215 /* keeps fsck and non-quota versions of reiserfs happy */
1218 }
1220 /*
1221 * files from before the quota patch might i_blocks such that
1222 * bytes < real_space. Deal with that here to prevent it from
1223 * going negative.
1224 */
1228 }
1230 /*
1231 * BAD: new directories have stat data of new type and all other items
1232 * of old type. Version stored in the inode says about body items, so
1233 * in update_stat_data we can not rely on inode, but have to check
1234 * item version directly
1235 */
1237 /* called by read_locked_inode */
1239 {
1242 __u32 rdev;
1281 /*
1282 * there was a bug in <=3.5.23 when i_blocks could take
1283 * negative values. Starting from 3.5.17 this value could
1284 * even be stored in stat data. For such files we set
1285 * i_blocks based on file size. Just 2 notes: this can be
1286 * wrong for sparse files. On-disk value will be only
1287 * updated if file's inode will ever change
1288 */
1291 }
1297 /*
1298 * an early bug in the quota code can give us an odd
1299 * number for the block count. This is incorrect, fix it here.
1300 */
1303 }
1306 SD_V1_SIZE));
1307 /*
1308 * nopack is initially zero for v1 objects. For v2 objects,
1309 * nopack is initialised from sd_attrs
1310 */
1313 /*
1314 * new stat data found, but object may have old items
1315 * (directories and symlinks)
1316 */
1335 else
1340 else
1346 SD_V2_SIZE));
1347 /*
1348 * read persistent inode attributes from sd and initialise
1349 * generic inode flags from them
1350 */
1353 }
1371 }
1372 }
1374 /* update new stat data with inode fields */
1376 {
1378 __u16 flags;
1391 else
1396 }
1398 /* used to copy inode's fields to old stat data */
1400 {
1414 else
1417 /* Sigh. i_first_direct_byte is back */
1420 }
1422 /*
1423 * NOTE, you must prepare the buffer head before sending it here,
1424 * and then log it after the call
1425 */
1427 loff_t size)
1428 {
1439 /* path points to old stat data */
1444 }
1447 }
1451 {
1461 /* key type is unimportant */
1466 /* look for the object's stat data */
1470 "i/o failure occurred trying to "
1473 }
1478 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1480 }
1482 "stat data of object %k (nlink == %d) "
1485 pos);
1488 }
1490 /*
1491 * sigh, prepare_for_journal might schedule. When it
1492 * schedules the FS might change. We have to detect that,
1493 * and loop back to the search if the stat data item has moved
1494 */
1501 /* Stat_data item has been moved after scheduling. */
1506 }
1508 }
1513 }
1515 /*
1516 * reiserfs_read_locked_inode is called to read the inode off disk, and it
1517 * does a make_bad_inode when things go wrong. But, we need to make sure
1518 * and clear the key in the private portion of the inode, otherwise a
1519 * corresponding iput might try to delete whatever object the inode last
1520 * represented.
1521 */
1523 {
1526 }
1528 /*
1529 * initially this function was derived from minix or ext2's analog and
1530 * evolved as the prototype did
1531 */
1533 {
1538 }
1540 /*
1541 * looks for stat data in the tree, and fills up the fields of in-core
1542 * inode stat data fields
1543 */
1546 {
1554 /*
1555 * set version 1, version 2 could be used too, because stat data
1556 * key is the same in both versions
1557 */
1564 /* look for the object's stat data */
1568 "i/o failure occurred trying to find "
1572 }
1574 /* a stale NFS handle can trigger this without it being an error */
1580 }
1584 /*
1585 * It is possible that knfsd is trying to access inode of a file
1586 * that is being removed from the disk by some other thread. As we
1587 * update sd on unlink all that is required is to check for nlink
1588 * here. This bug was first found by Sizif when debugging
1589 * SquidNG/Butterfly, forgotten, and found again after Philippe
1590 * Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
1592 * More logical fix would require changes in fs/inode.c:iput() to
1593 * remove inode from hash-table _after_ fs cleaned disk stuff up and
1594 * in iget() to return NULL if I_FREEING inode is found in
1595 * hash-table.
1596 */
1598 /*
1599 * Currently there is one place where it's ok to meet inode with
1600 * nlink==0: processing of open-unlinked and half-truncated files
1601 * during mount (fs/reiserfs/super.c:finish_unfinished()).
1602 */
1606 "dead inode read from disk %K. "
1610 }
1612 /* init inode should be relsing */
1615 /*
1616 * Stat data v1 doesn't support ACLs.
1617 */
1620 }
1622 /*
1623 * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().
1624 *
1625 * @inode: inode from hash table to check
1626 * @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.
1627 *
1628 * This function is called by iget5_locked() to distinguish reiserfs inodes
1629 * having the same inode numbers. Such inodes can only exist due to some
1630 * error condition. One of them should be bad. Inodes with identical
1631 * inode numbers (objectids) are distinguished by parent directory ids.
1632 *
1633 */
1635 {
1639 /* args is already in CPU order */
1642 }
1645 {
1663 }
1666 /* either due to i/o error or a stale NFS handle */
1669 }
1671 }
1676 {
1688 }
1692 }
1696 {
1697 /*
1698 * fhtype happens to reflect the number of u32s encoded.
1699 * due to a bug in earlier code, fhtype might indicate there
1700 * are more u32s then actually fitted.
1701 * so if fhtype seems to be more than len, reduce fhtype.
1702 * Valid types are:
1703 * 2 - objectid + dir_id - legacy support
1704 * 3 - objectid + dir_id + generation
1705 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1706 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1707 * 6 - as above plus generation of directory
1708 * 6 does not fit in NFSv2 handles
1709 */
1716 }
1722 }
1726 {
1736 }
1740 {
1749 }
1762 }
1763 }
1765 }
1767 /*
1768 * looks for stat data, then copies fields to it, marks the buffer
1769 * containing stat data as dirty
1770 */
1771 /*
1772 * reiserfs inodes are never really dirty, since the dirty inode call
1773 * always logs them. This call allows the VFS inode marking routines
1774 * to properly mark inodes for datasync and such, but only actually
1775 * does something when called for a synchronous update.
1776 */
1778 {
1784 /*
1785 * memory pressure can sometimes initiate write_inode calls with
1786 * sync == 1,
1787 * these cases are just when the system needs ram, not when the
1788 * inode needs to reach disk for safety, and they can safely be
1789 * ignored because the altered inode has already been logged.
1790 */
1796 }
1798 }
1800 }
1802 /*
1803 * stat data of new object is inserted already, this inserts the item
1804 * containing "." and ".." entries
1805 */
1810 {
1823 /*
1824 * compose item head for new item. Directories consist of items of
1825 * old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1826 * is done by reiserfs_new_inode
1827 */
1844 }
1846 /* look for place in the tree for new item */
1852 }
1859 }
1861 /* insert item, that is empty directory item */
1863 }
1865 /*
1866 * stat data of object has been inserted, this inserts the item
1867 * containing the body of symlink
1868 */
1874 {
1889 /* look for place in the tree for new item */
1895 }
1902 }
1904 /* insert item, that is body of symlink */
1906 }
1908 /*
1909 * inserts the stat data into the tree, and then calls
1910 * reiserfs_new_directory (to insert ".", ".." item if new object is
1911 * directory) or reiserfs_new_symlink (to insert symlink body if new
1912 * object is symlink) or nothing (if new object is regular file)
1914 * NOTE! uid and gid must already be set in the inode. If we return
1915 * non-zero due to an error, we have to drop the quota previously allocated
1916 * for the fresh inode. This can only be done outside a transaction, so
1917 * if we return non-zero, we also end the transaction.
1918 *
1919 * @th: active transaction handle
1920 * @dir: parent directory for new inode
1921 * @mode: mode of new inode
1922 * @symname: symlink contents if inode is symlink
1923 * @isize: 0 for regular file, EMPTY_DIR_SIZE for dirs, strlen(symname) for
1924 * symlinks
1925 * @inode: inode to be filled
1926 * @security: optional security context to associate with this inode
1927 */
1930 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1931 strlen (symname) for symlinks) */
1935 {
1956 }
1958 /* item head of new item */
1964 }
1969 else
1982 }
1985 /*
1986 * not a perfect generation count, as object ids can be reused,
1987 * but this is as good as reiserfs can do right now.
1988 * note that the private part of inode isn't filled in yet,
1989 * we have to use the directory.
1990 */
1992 else
1993 #if defined( USE_INODE_GENERATION_COUNTER )
1996 #else
1998 #endif
2000 /* fill stat data */
2003 /* uid and gid must already be set by the caller for quota init */
2005 /* symlink cannot be immutable or append only, right? */
2027 /* key to search for correct place for new stat data */
2032 /* find proper place for inserting of stat data */
2037 }
2042 }
2044 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
2049 }
2053 }
2054 /*
2055 * store in in-core inode the key of stat data and version all
2056 * object items will have (directory items will have old offset
2057 * format, other new objects will consist of new items)
2058 */
2061 else
2065 else
2068 /* insert the stat data into the tree */
2069 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
2072 #endif
2073 retval =
2080 }
2081 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
2084 #endif
2086 /* insert item with "." and ".." */
2087 retval =
2089 }
2092 /* insert body of symlink */
2095 retval =
2097 i_size);
2098 }
2104 }
2115 }
2118 "ACLs aren't enabled in the fs, "
2134 }
2135 }
2142 out_bad_inode:
2143 /* Invalidate the object, nothing was inserted yet */
2146 /* Quota change must be inside a transaction for journaling */
2151 out_end_trans:
2153 /*
2154 * Drop can be outside and it needs more credits so it's better
2155 * to have it outside
2156 */
2163 out_inserted_sd:
2169 }
2171 /*
2172 * finds the tail page in the page cache,
2173 * reads the last block in.
2174 *
2175 * On success, page_result is set to a locked, pinned page, and bh_result
2176 * is set to an up to date buffer for the last block in the file. returns 0.
2177 *
2178 * tail conversion is not done, so bh_result might not be valid for writing
2179 * check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
2180 * trying to write the block.
2181 *
2182 * on failure, nonzero is returned, page_result and bh_result are untouched.
2183 */
2187 {
2189 /*
2190 * we want the page with the last byte in the file,
2191 * not the page that will hold the next byte for appending
2192 */
2203 /*
2204 * we know that we are only called with inode->i_size > 0.
2205 * we also know that a file tail can never be as big as a block
2206 * If i_size % blocksize == 0, our file is currently block aligned
2207 * and it won't need converting or zeroing after a truncate.
2208 */
2211 }
2216 }
2217 /* start within the page of the last block in the file */
2221 reiserfs_get_block_create_0);
2230 }
2236 /*
2237 * note, this should never happen, prepare_write should be
2238 * taking care of this for us. If the buffer isn't up to
2239 * date, I've screwed up the code to find the buffer, or the
2240 * code to call prepare_write
2241 */
2246 }
2250 out:
2253 unlock:
2257 }
2259 /*
2260 * vfs version of truncate file. Must NOT be called with
2261 * a transaction already started.
2262 *
2263 * some code taken from block_truncate_page
2264 */
2266 {
2268 /* we want the offset for the first byte after the end of the file */
2282 /*
2283 * -ENOENT means we truncated past the end of the
2284 * file, and get_block_create_0 could not find a
2285 * block to read in, which is ok.
2286 */
2290 error);
2293 }
2294 }
2296 /*
2297 * so, if page != NULL, we have a buffer head for the offset at
2298 * the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2299 * then we have an unformatted node. Otherwise, we have a direct item,
2300 * and no zeroing is required on disk. We zero after the truncate,
2301 * because the truncate might pack the item anyway
2302 * (it will unmap bh if it packs).
2303 *
2304 * it is enough to reserve space in transaction for 2 balancings:
2305 * one for "save" link adding and another for the first
2306 * cut_from_item. 1 is for update_sd
2307 */
2314 /*
2315 * we are doing real truncate: if the system crashes
2316 * before the last transaction of truncating gets committed
2317 * - on reboot the file either appears truncated properly
2318 * or not truncated at all
2319 */
2326 /* check reiserfs_do_truncate after ending the transaction */
2330 }
2336 }
2340 /* if we are not on a block boundary */
2346 }
2347 }
2350 }
2355 out:
2359 }
2364 }
2369 {
2387 /*
2388 * catch places below that try to log something without
2389 * starting a trans
2390 */
2395 }
2398 start_over:
2402 research:
2407 }
2414 /* we've found an unformatted node */
2419 }
2421 /* crap, we are writing to a hole */
2424 }
2437 /* vs-3050 is gone, no need to drop the path */
2446 bh);
2448 }
2449 }
2457 }
2460 copy_size);
2466 /* are there still bytes left? */
2471 copy_size);
2473 }
2479 }
2482 out:
2489 }
2492 /* this is where we fill in holes in the file. */
2495 GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
2500 /* get_block failed to find a mapped unformatted node. */
2503 }
2504 }
2505 }
2509 /*
2510 * we've copied data from the page into the direct item, so the
2511 * buffer in the page is now clean, mark it to reflect that.
2512 */
2516 }
2518 }
2520 /*
2521 * mason@suse.com: updated in 2.5.54 to follow the same general io
2522 * start/recovery path as __block_write_full_page, along with special
2523 * code to handle reiserfs tails.
2524 */
2527 {
2532 sector_t last_block;
2542 /* no logging allowed when nonblocking or from PF_MEMALLOC */
2547 }
2549 /*
2550 * The page dirty bit is cleared before writepage is called, which
2551 * means we have to tell create_empty_buffers to make dirty buffers
2552 * The page really should be up to date at this point, so tossing
2553 * in the BH_Uptodate is just a sanity check.
2554 */
2558 }
2561 /*
2562 * last page in the file, zero out any contents past the
2563 * last byte in the file
2564 */
2569 /* no file contents in this page */
2573 }
2575 }
2579 /* first map all the buffers, logging any direct items we find */
2582 /*
2583 * This can happen when the block size is less than
2584 * the page size. The corresponding bytes in the page
2585 * were zero filled above
2586 */
2593 /*
2594 * not mapped yet, or it points to a direct item, search
2595 * the btree for the mapping info, and log any direct
2596 * items found
2597 */
2600 }
2601 }
2603 block++;
2606 /*
2607 * we start the transaction after map_block_for_writepage,
2608 * because it can create holes in the file (an unbounded operation).
2609 * starting it here, we can make a reliable estimate for how many
2610 * blocks we're going to log
2611 */
2619 }
2621 }
2622 /* now go through and lock any dirty buffers on the page */
2634 }
2635 /*
2636 * from this point on, we know the buffer is mapped to a
2637 * real block and not a direct item
2638 */
2645 }
2646 }
2651 }
2659 }
2664 /*
2665 * since any buffer might be the only dirty buffer on the page,
2666 * the first submit_bh can bring the page out of writeback.
2667 * be careful with the buffers.
2668 */
2673 nr++;
2674 }
2680 done:
2682 /*
2683 * if this page only had a direct item, it is very possible for
2684 * no io to be required without there being an error. Or,
2685 * someone else could have locked them and sent them down the
2686 * pipe without locking the page
2687 */
2693 }
2699 }
2702 fail:
2703 /*
2704 * catches various errors, we need to make sure any valid dirty blocks
2705 * get to the media. The page is currently locked and not marked for
2706 * writeback
2707 */
2716 /*
2717 * clear any dirty bits that might have come from
2718 * getting attached to a dirty page
2719 */
2721 }
2733 nr++;
2734 }
2739 }
2742 {
2744 }
2747 {
2751 }
2754 {
2757 }
2763 {
2766 pgoff_t index;
2774 pos ++;
2776 }
2789 journal_info;
2794 }
2798 /*
2799 * this gets a little ugly. If reiserfs_get_block returned an
2800 * error and left a transacstion running, we've got to close
2801 * it, and we've got to free handle if it was a persistent
2802 * transaction.
2803 *
2804 * But, if we had nested into an existing transaction, we need
2805 * to just drop the ref count on the handle.
2806 *
2807 * If old_ref == 0, the transaction is from reiserfs_get_block,
2808 * and it was a persistent trans. Otherwise, it was nested
2809 * above.
2810 */
2821 }
2822 }
2823 }
2827 /* Truncate allocated blocks */
2829 }
2831 }
2834 {
2848 journal_info;
2853 }
2858 /*
2859 * this gets a little ugly. If reiserfs_get_block returned an
2860 * error and left a transacstion running, we've got to close
2861 * it, and we've got to free handle if it was a persistent
2862 * transaction.
2863 *
2864 * But, if we had nested into an existing transaction, we need
2865 * to just drop the ref count on the handle.
2866 *
2867 * If old_ref == 0, the transaction is from reiserfs_get_block,
2868 * and it was a persistent trans. Otherwise, it was nested
2869 * above.
2870 */
2881 }
2882 }
2883 }
2886 }
2889 {
2891 }
2896 {
2905 pos ++;
2910 else
2919 }
2924 /*
2925 * generic_commit_write does this for us, but does not update the
2926 * transaction tracking stuff when the size changes. So, we have
2927 * to do the i_size updates here.
2928 */
2933 /*
2934 * If the file have grown beyond the border where it
2935 * can have a tail, unmark it as needing a tail
2936 * packing
2937 */
2950 /*
2951 * this will just nest into our transaction. It's important
2952 * to use mark_inode_dirty so the inode gets pushed around on
2953 * the dirty lists, and so that O_SYNC works as expected
2954 */
2961 }
2966 }
2972 }
2974 out:
2985 journal_error:
2992 }
2994 }
2998 {
3012 }
3015 /*
3016 * generic_commit_write does this for us, but does not update the
3017 * transaction tracking stuff when the size changes. So, we have
3018 * to do the i_size updates here.
3019 */
3022 /*
3023 * If the file have grown beyond the border where it
3024 * can have a tail, unmark it as needing a tail
3025 * packing
3026 */
3039 /*
3040 * this will just nest into our transaction. It's important
3041 * to use mark_inode_dirty so the inode gets pushed around
3042 * on the dirty lists, and so that O_SYNC works as expected
3043 */
3050 }
3057 }
3059 out:
3062 journal_error:
3067 }
3070 }
3073 {
3077 else
3081 else
3085 else
3089 else
3093 else
3095 }
3096 }
3099 {
3103 else
3107 else
3111 else
3115 else
3117 }
3118 }
3120 /*
3121 * decide if this buffer needs to stay around for data logging or ordered
3122 * write purposes
3123 */
3125 {
3133 }
3134 /*
3135 * the page is locked, and the only places that log a data buffer
3136 * also lock the page.
3137 */
3139 /*
3140 * very conservative, leave the buffer pinned if
3141 * anyone might need it.
3142 */
3145 }
3150 /*
3151 * why is this safe?
3152 * reiserfs_setattr updates i_size in the on disk
3153 * stat data before allowing vmtruncate to be called.
3154 *
3155 * If buffer was put onto the ordered list for this
3156 * transaction, we know for sure either this transaction
3157 * or an older one already has updated i_size on disk,
3158 * and this ordered data won't be referenced in the file
3159 * if we crash.
3160 *
3161 * if the buffer was put onto the ordered list for an older
3162 * transaction, we need to leave it around
3163 */
3167 }
3168 free_jh:
3171 }
3175 }
3177 /* clm -- taken from fs/buffer.c:block_invalidate_page */
3180 {
3205 /*
3206 * is this block fully invalidated?
3207 */
3211 else
3213 }
3218 /*
3219 * We release buffers only if the entire page is being invalidated.
3220 * The get_block cached value has been unconditionally invalidated,
3221 * so real IO is not possible anymore.
3222 */
3225 /* maybe should BUG_ON(!ret); - neilb */
3226 }
3227 out:
3229 }
3232 {
3237 }
3239 }
3241 /*
3242 * Returns 1 if the page's buffers were dropped. The page is locked.
3243 *
3244 * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads
3245 * in the buffers at page_buffers(page).
3246 *
3247 * even in -o notail mode, we can't be sure an old mount without -o notail
3248 * didn't create files with tails.
3249 */
3251 {
3269 }
3270 }
3277 }
3279 /*
3280 * We thank Mingming Cao for helping us understand in great detail what
3281 * to do in this section of the code.
3282 */
3284 {
3288 ssize_t ret;
3291 reiserfs_get_blocks_direct_io);
3293 /*
3294 * In case of error extending write may have instantiated a few
3295 * blocks outside i_size. Trim these off again.
3296 */
3304 }
3305 }
3308 }
3311 {
3320 /* must be turned off for recursive notify_change calls */
3327 }
3330 /*
3331 * version 2 items will be caught by the s_maxbytes check
3332 * done for us in vmtruncate
3333 */
3339 }
3343 /* fill in hole pointers in the expanding truncate case. */
3349 /* we're changing at most 2 bitmaps, inode + super */
3354 }
3357 }
3361 }
3362 /*
3363 * file size is changed, ctime and mtime are
3364 * to be updated
3365 */
3367 }
3368 }
3374 /* stat data of format v3.5 has 16 bit uid and gid */
3377 }
3393 /*
3394 * (user+group)*(old+new) structure - we count quota
3395 * info and , inode write (sb, inode)
3396 */
3408 }
3410 /*
3411 * Update corresponding info in inode so that everything
3412 * is in one transaction
3413 */
3423 }
3429 /*
3430 * Could race against reiserfs_file_release
3431 * if called from NFS, so take tailpack mutex.
3432 */
3437 }
3438 }
3443 }
3448 }
3450 out:
3452 }
3465 };