| blob | 9531b6c18ac7bf4b944e75bd58a0c0ecbb40783a |
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>
27 {
28 /*
29 * We need blocks for transaction + (user+group) quota
30 * update (possibly delete)
31 */
45 /*
46 * The = 0 happens when we abort creating a new inode
47 * for some reason like lack of space..
48 * also handles bad_inode case
49 */
64 /*
65 * Do quota update inside a transaction for journaled quotas.
66 * We must do that after delete_object so that quota updates
67 * go into the same transaction as stat data deletion
68 */
73 }
78 /*
79 * check return value from reiserfs_delete_object after
80 * ending the transaction
81 */
85 /*
86 * all items of file are deleted, so we can remove
87 * "save" link
88 * we can't do anything about an error here
89 */
91 out:
94 /* no object items are in the tree */
95 ;
96 }
98 /* note this must go after the journal_end to prevent deadlock */
105 no_delete:
108 }
112 {
120 }
122 /*
123 * take base of inode_key (it comes from inode always) (dirid, objectid)
124 * and version from an inode, set offset and type of key
125 */
128 {
132 length);
133 }
135 /* when key is 0, do not set version and short key */
140 {
145 }
150 /* set_ih_free_space (ih, 0); */
151 /*
152 * for directory items it is entry count, for directs and stat
153 * datas - 0xffff, for indirects - 0
154 */
156 }
158 /*
159 * FIXME: we might cache recently accessed indirect item
160 * Ugh. Not too eager for that....
161 * I cut the code until such time as I see a convincing argument (benchmark).
162 * I don't want a bloated inode struct..., and I don't like code complexity....
163 */
165 /*
166 * cutting the code is fine, since it really isn't in use yet and is easy
167 * to add back in. But, Vladimir has a really good idea here. Think
168 * about what happens for reading a file. For each page,
169 * The VFS layer calls reiserfs_readpage, who searches the tree to find
170 * an indirect item. This indirect item has X number of pointers, where
171 * X is a big number if we've done the block allocation right. But,
172 * we only use one or two of these pointers during each call to readpage,
173 * needlessly researching again later on.
174 *
175 * The size of the cache could be dynamic based on the size of the file.
176 *
177 * I'd also like to see us cache the location the stat data item, since
178 * we are needlessly researching for that frequently.
179 *
180 * --chris
181 */
183 /*
184 * If this page has a file tail in it, and
185 * it was read in by get_block_create_0, the page data is valid,
186 * but tail is still sitting in a direct item, and we can't write to
187 * it. So, look through this page, and check all the mapped buffers
188 * to make sure they have valid block numbers. Any that don't need
189 * to be unmapped, so that __block_write_begin will correctly call
190 * reiserfs_get_block to convert the tail into an unformatted node
191 */
193 {
203 }
206 }
207 }
209 /*
210 * reiserfs_get_block does not need to allocate a block only if it has been
211 * done already or non-hole position has been found in the indirect item
212 */
216 {
223 }
226 {
228 }
232 {
234 }
236 /*
237 * files which were created in the earlier version can not be longer,
238 * than 2 gb
239 */
241 {
242 /* it is new file. */
244 /* old file, but 'block' is inside of 2gb */
249 }
253 {
262 /* we cannot restart while nested */
265 }
272 }
274 }
276 /*
277 * it is called by get_block when create == 0. Returns block number
278 * for 'block'-th logical block of file. When it hits direct item it
279 * returns 0 (being called from bmap) or read direct item into piece
280 * of page (bh_result)
281 * Please improve the english/clarity in the comment above, as it is
282 * hard to understand.
283 */
286 {
291 b_blocknr_t blocknr;
299 /* prepare the key to look for the 'block'-th block of file */
311 /*
312 * We do not return -ENOENT if there is a hole but page is
313 * uptodate, because it means that there is some MMAPED data
314 * associated with it that is yet to be written to disk.
315 */
319 }
321 }
328 /*
329 * FIXME: here we could cache indirect item or part of it in
330 * the inode to avoid search_by_key in case of subsequent
331 * access to file
332 */
340 }
342 /*
343 * We do not return -ENOENT if there is a hole but
344 * page is uptodate, because it means that there is
345 * some MMAPED data associated with it that is
346 * yet to be written to disk.
347 */
351 }
357 }
358 /* requested data are in direct item(s) */
360 /*
361 * we are called by bmap. FIXME: we can not map block of file
362 * when it is stored in direct item(s)
363 */
368 }
370 /*
371 * if we've got a direct item, and the buffer or page was uptodate,
372 * we don't want to pull data off disk again. skip to the
373 * end, where we map the buffer and return
374 */
378 /*
379 * grab_tail_page can trigger calls to reiserfs_get_block on
380 * up to date pages without any buffers. If the page is up
381 * to date, we don't want read old data off disk. Set the up
382 * to date bit on the buffer instead and jump to the end
383 */
387 }
388 /* read file tail into part of page */
392 /*
393 * we only want to kmap if we are reading the tail into the page.
394 * this is not the common case, so we don't kmap until we are
395 * sure we need to. But, this means the item might move if
396 * kmap schedules
397 */
406 }
407 /*
408 * make sure we don't read more bytes than actually exist in
409 * the file. This can happen in odd cases where i_size isn't
410 * correct, and when direct item padding results in a few
411 * extra bytes at the end of the direct item
412 */
416 chars =
422 }
430 /*
431 * we done, if read direct item is not the last item of
432 * node FIXME: we could try to check right delimiting key
433 * to see whether direct item continues in the right
434 * neighbor or rely on i_size
435 */
439 /* update key to look for the next piece */
443 /* i/o error most likely */
452 finished:
458 /*
459 * this buffer has valid data, but isn't valid for io. mapping it to
460 * block #0 tells the rest of reiserfs it just has a tail in it
461 */
465 }
467 /*
468 * this is called to create file map. So, _get_block_create_0 will not
469 * read direct item
470 */
473 {
478 /* do not read the direct item */
482 }
484 /*
485 * special version of get_block that is only used by grab_tail_page right
486 * now. It is sent to __block_write_begin, and when you try to get a
487 * block past the end of the file (or a block from a hole) it returns
488 * -ENOENT instead of a valid buffer. __block_write_begin expects to
489 * be able to do i/o on the buffers returned, unless an error value
490 * is also returned.
491 *
492 * So, this allows __block_write_begin to be used for reading a single block
493 * in a page. Where it does not produce a valid page for holes, or past the
494 * end of the file. This turns out to be exactly what we need for reading
495 * tails for conversion.
496 *
497 * The point of the wrapper is forcing a certain value for create, even
498 * though the VFS layer is calling this function with create==1. If you
499 * don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
500 * don't use this function.
501 */
505 {
507 }
509 /*
510 * This is special helper for reiserfs_get_block in case we are executing
511 * direct_IO request.
512 */
514 sector_t iblock,
517 {
522 /*
523 * We set the b_size before reiserfs_get_block call since it is
524 * referenced in convert_tail_for_hole() that may be called from
525 * reiserfs_get_block()
526 */
534 /* don't allow direct io onto tail pages */
536 /*
537 * make sure future calls to the direct io funcs for this
538 * offset in the file fail by unmapping the buffer
539 */
542 }
544 /*
545 * Possible unpacked tail. Flush the data before pages have
546 * disappeared
547 */
560 }
561 out:
563 }
565 /*
566 * helper function for when reiserfs_get_block is called for a hole
567 * but the file tail is still in a direct item
568 * bh_result is the buffer head for the hole
569 * tail_offset is the offset of the start of the tail in the file
570 *
571 * This calls prepare_write, which will start a new transaction
572 * you should not be in a transaction, or have any paths held when you
573 * call this.
574 */
577 loff_t tail_offset)
578 {
589 /* always try to read until the end of the block */
594 /*
595 * hole_page can be zero in case of direct_io, we are sure
596 * that we cannot get here if we write with O_DIRECT into tail page
597 */
603 }
606 }
608 /*
609 * we don't have to make sure the conversion did not happen while
610 * we were locking the page because anyone that could convert
611 * must first take i_mutex.
612 *
613 * We must fix the tail page for writing because it might have buffers
614 * that are mapped, but have a block number of 0. This indicates tail
615 * data that has been read directly into the page, and
616 * __block_write_begin won't trigger a get_block in this case.
617 */
624 /* tail conversion might change the data in the page */
629 unlock:
633 }
634 out:
636 }
639 sector_t block,
643 {
646 #ifdef REISERFS_PREALLOCATE
650 }
651 #endif
653 block);
654 }
658 {
660 /* b_blocknr_t is (unsigned) 32 bit int*/
671 /*
672 * space reserved in transaction batch:
673 * . 3 balancings in direct->indirect conversion
674 * . 1 block involved into reiserfs_update_sd()
675 * XXX in practically impossible worst case direct2indirect()
676 * can incur (much) more than 3 balancings.
677 * quota update for user, group
678 */
684 loff_t new_offset =
693 }
695 /*
696 * if !create, we aren't changing the FS, so we don't need to
697 * log anything, so we don't need to start a transaction
698 */
701 /* find number of block-th logical block of the file */
706 }
708 /*
709 * if we're already in a transaction, make sure to close
710 * any new transactions we start in this func
711 */
716 /*
717 * If file is of such a size, that it might have a tail and
718 * tails are enabled we should mark it as possibly needing
719 * tail packing on close
720 */
727 /* set the key of the first byte in the 'block'-th block of file */
730 start_trans:
735 }
737 }
738 research:
744 }
756 /* we have to allocate block for the unformatted node */
760 }
762 repeat =
766 /*
767 * restart the transaction to give the journal a chance to free
768 * some blocks. releases the path, so we have to go back to
769 * research if we succeed on the second try
770 */
776 repeat =
782 }
785 else
788 }
793 }
794 }
797 b_blocknr_t unfm_ptr;
798 /*
799 * 'block'-th block is in the file already (there is
800 * corresponding cell in some indirect item). But it may be
801 * zero unformatted node pointer (hole)
802 */
805 /* use allocated block to plug the hole */
810 bh);
812 }
821 }
830 /*
831 * the item was found, so new blocks were not added to the file
832 * there is no need to make sure the inode is updated with this
833 * transaction
834 */
836 }
841 }
843 /*
844 * desired position is not found or is in the direct item. We have
845 * to append file with holes up to 'block'-th block converting
846 * direct items to indirect one if necessary
847 */
854 /* indirect item has to be inserted */
859 /*
860 * we are going to add 'block'-th block to the file.
861 * Use allocated block for that
862 */
869 }
874 retval =
880 /*
881 * retval == -ENOSPC, -EDQUOT or -EIO
882 * or -EEXIST
883 */
885 }
887 /* direct item has to be converted */
888 loff_t tail_offset;
890 tail_offset =
894 /*
895 * direct item we just found fits into block we have
896 * to map. Convert it into unformatted node: use
897 * bh_result for the conversion
898 */
905 /*
906 * we have to pad file tail stored in direct
907 * item(s) up to block size and convert it
908 * to unformatted node. FIXME: this should
909 * also get into page cache
910 */
913 /*
914 * ugly, but we can only end the transaction if
915 * we aren't nested
916 */
919 retval =
920 reiserfs_end_persistent_transaction
925 }
927 retval =
929 tail_offset);
934 "convert tail failed "
937 retval);
939 /*
940 * the bitmap, the super,
941 * and the stat data == 3
942 */
947 inode,
948 allocated_block_nr,
950 }
952 }
954 }
955 retval =
957 tail_offset);
963 }
964 /*
965 * it is important the set_buffer_uptodate is done
966 * after the direct2indirect. The buffer might
967 * contain valid data newer than the data on disk
968 * (read by readpage, changed, and then sent here by
969 * writepage). direct2indirect needs to know if unbh
970 * was already up to date, so it can decide if the
971 * data in unbh needs to be replaced with data from
972 * the disk
973 */
976 /*
977 * unbh->b_page == NULL in case of DIRECT_IO request,
978 * this means buffer will disappear shortly, so it
979 * should not be added to
980 */
982 /*
983 * we've converted the tail, so we must
984 * flush unbh before the transaction commits
985 */
988 /*
989 * mark it dirty now to prevent commit_write
990 * from adding this buffer to the inode's
991 * dirty buffer list
992 */
993 /*
994 * AKPM: changed __mark_buffer_dirty to
995 * mark_buffer_dirty(). It's still atomic,
996 * but it sets the page dirty too, which makes
997 * it eligible for writeback at any time by the
998 * VM (which was also the case with
999 * __mark_buffer_dirty())
1000 */
1002 }
1004 /*
1005 * append indirect item with holes if needed, when
1006 * appending pointer to 'block'-th block use block,
1007 * which is already allocated
1008 */
1010 /*
1011 * We use this in case we need to allocate
1012 * only one block which is a fastpath
1013 */
1016 __u64 max_to_insert =
1018 UNFM_P_SIZE;
1019 __u64 blocks_needed;
1023 /*
1024 * indirect item has to be appended,
1025 * set up key of that position
1026 * (key type is unimportant)
1027 */
1037 blocks_needed =
1041 s_blocksize_bits);
1051 }
1052 }
1054 /*
1055 * we are going to add target block to
1056 * the file. Use allocated block for that
1057 */
1065 /* paste hole to the indirect item */
1066 /*
1067 * If kmalloc failed, max_to_insert becomes
1068 * zero and it means we only have space for
1069 * one block
1070 */
1071 blocks_needed =
1073 }
1074 retval =
1077 UNFM_P_SIZE *
1078 blocks_needed);
1087 }
1089 /*
1090 * We need to mark new file size in case
1091 * this function will be interrupted/aborted
1092 * later on. And we may do this only for
1093 * holes.
1094 */
1097 }
1098 }
1103 /*
1104 * this loop could log more blocks than we had originally
1105 * asked for. So, we have to allow the transaction to end
1106 * if it is too big or too full. Update the inode so things
1107 * are consistent if we crash before the function returns
1108 * release the path so that anybody waiting on the path before
1109 * ending their transaction will be able to continue.
1110 */
1115 }
1116 /*
1117 * inserting indirect pointers for a hole can take a
1118 * long time. reschedule if needed and also release the write
1119 * lock for others.
1120 */
1127 }
1137 }
1146 failure:
1154 }
1159 }
1161 static int
1164 {
1166 }
1168 /*
1169 * Compute real number of used bytes by file
1170 * Following three functions can go away when we'll have enough space in
1171 * stat item
1172 */
1174 {
1181 /*
1182 * End of file is also in full block with indirect reference, so round
1183 * up to the next block.
1184 *
1185 * there is just no way to know if the tail is actually packed
1186 * on the file, so we have to assume it isn't. When we pack the
1187 * tail, we add 4 bytes to pretend there really is an unformatted
1188 * node pointer
1189 */
1190 bytes =
1193 sd_size;
1195 }
1199 {
1203 }
1206 }
1208 /* Compute number of blocks used by file in ReiserFS counting */
1210 {
1214 /* keeps fsck and non-quota versions of reiserfs happy */
1217 }
1219 /*
1220 * files from before the quota patch might i_blocks such that
1221 * bytes < real_space. Deal with that here to prevent it from
1222 * going negative.
1223 */
1227 }
1229 /*
1230 * BAD: new directories have stat data of new type and all other items
1231 * of old type. Version stored in the inode says about body items, so
1232 * in update_stat_data we can not rely on inode, but have to check
1233 * item version directly
1234 */
1236 /* called by read_locked_inode */
1238 {
1241 __u32 rdev;
1280 /*
1281 * there was a bug in <=3.5.23 when i_blocks could take
1282 * negative values. Starting from 3.5.17 this value could
1283 * even be stored in stat data. For such files we set
1284 * i_blocks based on file size. Just 2 notes: this can be
1285 * wrong for sparse files. On-disk value will be only
1286 * updated if file's inode will ever change
1287 */
1290 }
1296 /*
1297 * an early bug in the quota code can give us an odd
1298 * number for the block count. This is incorrect, fix it here.
1299 */
1302 }
1305 SD_V1_SIZE));
1306 /*
1307 * nopack is initially zero for v1 objects. For v2 objects,
1308 * nopack is initialised from sd_attrs
1309 */
1312 /*
1313 * new stat data found, but object may have old items
1314 * (directories and symlinks)
1315 */
1334 else
1339 else
1345 SD_V2_SIZE));
1346 /*
1347 * read persistent inode attributes from sd and initialise
1348 * generic inode flags from them
1349 */
1352 }
1370 }
1371 }
1373 /* update new stat data with inode fields */
1375 {
1377 __u16 flags;
1390 else
1395 }
1397 /* used to copy inode's fields to old stat data */
1399 {
1413 else
1416 /* Sigh. i_first_direct_byte is back */
1419 }
1421 /*
1422 * NOTE, you must prepare the buffer head before sending it here,
1423 * and then log it after the call
1424 */
1426 loff_t size)
1427 {
1438 /* path points to old stat data */
1443 }
1446 }
1450 {
1460 /* key type is unimportant */
1465 /* look for the object's stat data */
1469 "i/o failure occurred trying to "
1472 }
1477 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1479 }
1481 "stat data of object %k (nlink == %d) "
1484 pos);
1487 }
1489 /*
1490 * sigh, prepare_for_journal might schedule. When it
1491 * schedules the FS might change. We have to detect that,
1492 * and loop back to the search if the stat data item has moved
1493 */
1500 /* Stat_data item has been moved after scheduling. */
1505 }
1507 }
1512 }
1514 /*
1515 * reiserfs_read_locked_inode is called to read the inode off disk, and it
1516 * does a make_bad_inode when things go wrong. But, we need to make sure
1517 * and clear the key in the private portion of the inode, otherwise a
1518 * corresponding iput might try to delete whatever object the inode last
1519 * represented.
1520 */
1522 {
1525 }
1527 /*
1528 * initially this function was derived from minix or ext2's analog and
1529 * evolved as the prototype did
1530 */
1532 {
1537 }
1539 /*
1540 * looks for stat data in the tree, and fills up the fields of in-core
1541 * inode stat data fields
1542 */
1545 {
1553 /*
1554 * set version 1, version 2 could be used too, because stat data
1555 * key is the same in both versions
1556 */
1563 /* look for the object's stat data */
1567 "i/o failure occurred trying to find "
1571 }
1573 /* a stale NFS handle can trigger this without it being an error */
1579 }
1583 /*
1584 * It is possible that knfsd is trying to access inode of a file
1585 * that is being removed from the disk by some other thread. As we
1586 * update sd on unlink all that is required is to check for nlink
1587 * here. This bug was first found by Sizif when debugging
1588 * SquidNG/Butterfly, forgotten, and found again after Philippe
1589 * Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
1591 * More logical fix would require changes in fs/inode.c:iput() to
1592 * remove inode from hash-table _after_ fs cleaned disk stuff up and
1593 * in iget() to return NULL if I_FREEING inode is found in
1594 * hash-table.
1595 */
1597 /*
1598 * Currently there is one place where it's ok to meet inode with
1599 * nlink==0: processing of open-unlinked and half-truncated files
1600 * during mount (fs/reiserfs/super.c:finish_unfinished()).
1601 */
1605 "dead inode read from disk %K. "
1609 }
1611 /* init inode should be relsing */
1614 /*
1615 * Stat data v1 doesn't support ACLs.
1616 */
1619 }
1621 /*
1622 * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().
1623 *
1624 * @inode: inode from hash table to check
1625 * @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.
1626 *
1627 * This function is called by iget5_locked() to distinguish reiserfs inodes
1628 * having the same inode numbers. Such inodes can only exist due to some
1629 * error condition. One of them should be bad. Inodes with identical
1630 * inode numbers (objectids) are distinguished by parent directory ids.
1631 *
1632 */
1634 {
1638 /* args is already in CPU order */
1641 }
1644 {
1662 }
1665 /* either due to i/o error or a stale NFS handle */
1668 }
1670 }
1675 {
1687 }
1691 }
1695 {
1696 /*
1697 * fhtype happens to reflect the number of u32s encoded.
1698 * due to a bug in earlier code, fhtype might indicate there
1699 * are more u32s then actually fitted.
1700 * so if fhtype seems to be more than len, reduce fhtype.
1701 * Valid types are:
1702 * 2 - objectid + dir_id - legacy support
1703 * 3 - objectid + dir_id + generation
1704 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1705 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1706 * 6 - as above plus generation of directory
1707 * 6 does not fit in NFSv2 handles
1708 */
1715 }
1721 }
1725 {
1735 }
1739 {
1748 }
1761 }
1762 }
1764 }
1766 /*
1767 * looks for stat data, then copies fields to it, marks the buffer
1768 * containing stat data as dirty
1769 */
1770 /*
1771 * reiserfs inodes are never really dirty, since the dirty inode call
1772 * always logs them. This call allows the VFS inode marking routines
1773 * to properly mark inodes for datasync and such, but only actually
1774 * does something when called for a synchronous update.
1775 */
1777 {
1783 /*
1784 * memory pressure can sometimes initiate write_inode calls with
1785 * sync == 1,
1786 * these cases are just when the system needs ram, not when the
1787 * inode needs to reach disk for safety, and they can safely be
1788 * ignored because the altered inode has already been logged.
1789 */
1795 }
1797 }
1799 }
1801 /*
1802 * stat data of new object is inserted already, this inserts the item
1803 * containing "." and ".." entries
1804 */
1809 {
1822 /*
1823 * compose item head for new item. Directories consist of items of
1824 * old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1825 * is done by reiserfs_new_inode
1826 */
1843 }
1845 /* look for place in the tree for new item */
1851 }
1858 }
1860 /* insert item, that is empty directory item */
1862 }
1864 /*
1865 * stat data of object has been inserted, this inserts the item
1866 * containing the body of symlink
1867 */
1873 {
1888 /* look for place in the tree for new item */
1894 }
1901 }
1903 /* insert item, that is body of symlink */
1905 }
1907 /*
1908 * inserts the stat data into the tree, and then calls
1909 * reiserfs_new_directory (to insert ".", ".." item if new object is
1910 * directory) or reiserfs_new_symlink (to insert symlink body if new
1911 * object is symlink) or nothing (if new object is regular file)
1913 * NOTE! uid and gid must already be set in the inode. If we return
1914 * non-zero due to an error, we have to drop the quota previously allocated
1915 * for the fresh inode. This can only be done outside a transaction, so
1916 * if we return non-zero, we also end the transaction.
1917 *
1918 * @th: active transaction handle
1919 * @dir: parent directory for new inode
1920 * @mode: mode of new inode
1921 * @symname: symlink contents if inode is symlink
1922 * @isize: 0 for regular file, EMPTY_DIR_SIZE for dirs, strlen(symname) for
1923 * symlinks
1924 * @inode: inode to be filled
1925 * @security: optional security context to associate with this inode
1926 */
1929 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1930 strlen (symname) for symlinks) */
1934 {
1955 }
1957 /* item head of new item */
1963 }
1968 else
1981 }
1984 /*
1985 * not a perfect generation count, as object ids can be reused,
1986 * but this is as good as reiserfs can do right now.
1987 * note that the private part of inode isn't filled in yet,
1988 * we have to use the directory.
1989 */
1991 else
1992 #if defined( USE_INODE_GENERATION_COUNTER )
1995 #else
1997 #endif
1999 /* fill stat data */
2002 /* uid and gid must already be set by the caller for quota init */
2004 /* symlink cannot be immutable or append only, right? */
2026 /* key to search for correct place for new stat data */
2031 /* find proper place for inserting of stat data */
2036 }
2041 }
2043 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
2048 }
2052 }
2053 /*
2054 * store in in-core inode the key of stat data and version all
2055 * object items will have (directory items will have old offset
2056 * format, other new objects will consist of new items)
2057 */
2060 else
2064 else
2067 /* insert the stat data into the tree */
2068 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
2071 #endif
2072 retval =
2079 }
2080 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
2083 #endif
2085 /* insert item with "." and ".." */
2086 retval =
2088 }
2091 /* insert body of symlink */
2094 retval =
2096 i_size);
2097 }
2103 }
2105 /*
2106 * Mark it private if we're creating the privroot
2107 * or something under it.
2108 */
2112 }
2123 }
2126 "ACLs aren't enabled in the fs, "
2128 }
2141 }
2142 }
2149 out_bad_inode:
2150 /* Invalidate the object, nothing was inserted yet */
2153 /* Quota change must be inside a transaction for journaling */
2158 out_end_trans:
2160 /*
2161 * Drop can be outside and it needs more credits so it's better
2162 * to have it outside
2163 */
2170 out_inserted_sd:
2176 }
2178 /*
2179 * finds the tail page in the page cache,
2180 * reads the last block in.
2181 *
2182 * On success, page_result is set to a locked, pinned page, and bh_result
2183 * is set to an up to date buffer for the last block in the file. returns 0.
2184 *
2185 * tail conversion is not done, so bh_result might not be valid for writing
2186 * check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
2187 * trying to write the block.
2188 *
2189 * on failure, nonzero is returned, page_result and bh_result are untouched.
2190 */
2194 {
2196 /*
2197 * we want the page with the last byte in the file,
2198 * not the page that will hold the next byte for appending
2199 */
2210 /*
2211 * we know that we are only called with inode->i_size > 0.
2212 * we also know that a file tail can never be as big as a block
2213 * If i_size % blocksize == 0, our file is currently block aligned
2214 * and it won't need converting or zeroing after a truncate.
2215 */
2218 }
2223 }
2224 /* start within the page of the last block in the file */
2228 reiserfs_get_block_create_0);
2237 }
2243 /*
2244 * note, this should never happen, prepare_write should be
2245 * taking care of this for us. If the buffer isn't up to
2246 * date, I've screwed up the code to find the buffer, or the
2247 * code to call prepare_write
2248 */
2253 }
2257 out:
2260 unlock:
2264 }
2266 /*
2267 * vfs version of truncate file. Must NOT be called with
2268 * a transaction already started.
2269 *
2270 * some code taken from block_truncate_page
2271 */
2273 {
2275 /* we want the offset for the first byte after the end of the file */
2289 /*
2290 * -ENOENT means we truncated past the end of the
2291 * file, and get_block_create_0 could not find a
2292 * block to read in, which is ok.
2293 */
2297 error);
2300 }
2301 }
2303 /*
2304 * so, if page != NULL, we have a buffer head for the offset at
2305 * the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2306 * then we have an unformatted node. Otherwise, we have a direct item,
2307 * and no zeroing is required on disk. We zero after the truncate,
2308 * because the truncate might pack the item anyway
2309 * (it will unmap bh if it packs).
2310 *
2311 * it is enough to reserve space in transaction for 2 balancings:
2312 * one for "save" link adding and another for the first
2313 * cut_from_item. 1 is for update_sd
2314 */
2321 /*
2322 * we are doing real truncate: if the system crashes
2323 * before the last transaction of truncating gets committed
2324 * - on reboot the file either appears truncated properly
2325 * or not truncated at all
2326 */
2333 /* check reiserfs_do_truncate after ending the transaction */
2337 }
2343 }
2347 /* if we are not on a block boundary */
2353 }
2354 }
2357 }
2362 out:
2366 }
2371 }
2376 {
2394 /*
2395 * catch places below that try to log something without
2396 * starting a trans
2397 */
2402 }
2405 start_over:
2409 research:
2414 }
2421 /* we've found an unformatted node */
2426 }
2428 /* crap, we are writing to a hole */
2431 }
2444 /* vs-3050 is gone, no need to drop the path */
2453 bh);
2455 }
2456 }
2464 }
2467 copy_size);
2473 /* are there still bytes left? */
2478 copy_size);
2480 }
2486 }
2489 out:
2496 }
2499 /* this is where we fill in holes in the file. */
2502 GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
2507 /* get_block failed to find a mapped unformatted node. */
2510 }
2511 }
2512 }
2516 /*
2517 * we've copied data from the page into the direct item, so the
2518 * buffer in the page is now clean, mark it to reflect that.
2519 */
2523 }
2525 }
2527 /*
2528 * mason@suse.com: updated in 2.5.54 to follow the same general io
2529 * start/recovery path as __block_write_full_page, along with special
2530 * code to handle reiserfs tails.
2531 */
2534 {
2539 sector_t last_block;
2549 /* no logging allowed when nonblocking or from PF_MEMALLOC */
2554 }
2556 /*
2557 * The page dirty bit is cleared before writepage is called, which
2558 * means we have to tell create_empty_buffers to make dirty buffers
2559 * The page really should be up to date at this point, so tossing
2560 * in the BH_Uptodate is just a sanity check.
2561 */
2565 }
2568 /*
2569 * last page in the file, zero out any contents past the
2570 * last byte in the file
2571 */
2576 /* no file contents in this page */
2580 }
2582 }
2586 /* first map all the buffers, logging any direct items we find */
2589 /*
2590 * This can happen when the block size is less than
2591 * the page size. The corresponding bytes in the page
2592 * were zero filled above
2593 */
2600 /*
2601 * not mapped yet, or it points to a direct item, search
2602 * the btree for the mapping info, and log any direct
2603 * items found
2604 */
2607 }
2608 }
2610 block++;
2613 /*
2614 * we start the transaction after map_block_for_writepage,
2615 * because it can create holes in the file (an unbounded operation).
2616 * starting it here, we can make a reliable estimate for how many
2617 * blocks we're going to log
2618 */
2626 }
2628 }
2629 /* now go through and lock any dirty buffers on the page */
2641 }
2642 /*
2643 * from this point on, we know the buffer is mapped to a
2644 * real block and not a direct item
2645 */
2652 }
2653 }
2658 }
2666 }
2671 /*
2672 * since any buffer might be the only dirty buffer on the page,
2673 * the first submit_bh can bring the page out of writeback.
2674 * be careful with the buffers.
2675 */
2680 nr++;
2681 }
2687 done:
2689 /*
2690 * if this page only had a direct item, it is very possible for
2691 * no io to be required without there being an error. Or,
2692 * someone else could have locked them and sent them down the
2693 * pipe without locking the page
2694 */
2700 }
2706 }
2709 fail:
2710 /*
2711 * catches various errors, we need to make sure any valid dirty blocks
2712 * get to the media. The page is currently locked and not marked for
2713 * writeback
2714 */
2723 /*
2724 * clear any dirty bits that might have come from
2725 * getting attached to a dirty page
2726 */
2728 }
2740 nr++;
2741 }
2746 }
2749 {
2751 }
2754 {
2758 }
2761 {
2764 }
2770 {
2773 pgoff_t index;
2781 pos ++;
2783 }
2796 journal_info;
2801 }
2805 /*
2806 * this gets a little ugly. If reiserfs_get_block returned an
2807 * error and left a transacstion running, we've got to close
2808 * it, and we've got to free handle if it was a persistent
2809 * transaction.
2810 *
2811 * But, if we had nested into an existing transaction, we need
2812 * to just drop the ref count on the handle.
2813 *
2814 * If old_ref == 0, the transaction is from reiserfs_get_block,
2815 * and it was a persistent trans. Otherwise, it was nested
2816 * above.
2817 */
2828 }
2829 }
2830 }
2834 /* Truncate allocated blocks */
2836 }
2838 }
2841 {
2855 journal_info;
2860 }
2865 /*
2866 * this gets a little ugly. If reiserfs_get_block returned an
2867 * error and left a transacstion running, we've got to close
2868 * it, and we've got to free handle if it was a persistent
2869 * transaction.
2870 *
2871 * But, if we had nested into an existing transaction, we need
2872 * to just drop the ref count on the handle.
2873 *
2874 * If old_ref == 0, the transaction is from reiserfs_get_block,
2875 * and it was a persistent trans. Otherwise, it was nested
2876 * above.
2877 */
2888 }
2889 }
2890 }
2893 }
2896 {
2898 }
2903 {
2912 pos ++;
2917 else
2926 }
2931 /*
2932 * generic_commit_write does this for us, but does not update the
2933 * transaction tracking stuff when the size changes. So, we have
2934 * to do the i_size updates here.
2935 */
2940 /*
2941 * If the file have grown beyond the border where it
2942 * can have a tail, unmark it as needing a tail
2943 * packing
2944 */
2957 /*
2958 * this will just nest into our transaction. It's important
2959 * to use mark_inode_dirty so the inode gets pushed around on
2960 * the dirty lists, and so that O_SYNC works as expected
2961 */
2968 }
2973 }
2979 }
2981 out:
2992 journal_error:
2999 }
3001 }
3005 {
3019 }
3022 /*
3023 * generic_commit_write does this for us, but does not update the
3024 * transaction tracking stuff when the size changes. So, we have
3025 * to do the i_size updates here.
3026 */
3029 /*
3030 * If the file have grown beyond the border where it
3031 * can have a tail, unmark it as needing a tail
3032 * packing
3033 */
3046 /*
3047 * this will just nest into our transaction. It's important
3048 * to use mark_inode_dirty so the inode gets pushed around
3049 * on the dirty lists, and so that O_SYNC works as expected
3050 */
3057 }
3064 }
3066 out:
3069 journal_error:
3074 }
3077 }
3080 {
3084 else
3088 else
3092 else
3096 else
3100 else
3102 }
3103 }
3106 {
3110 else
3114 else
3118 else
3122 else
3124 }
3125 }
3127 /*
3128 * decide if this buffer needs to stay around for data logging or ordered
3129 * write purposes
3130 */
3132 {
3140 }
3141 /*
3142 * the page is locked, and the only places that log a data buffer
3143 * also lock the page.
3144 */
3146 /*
3147 * very conservative, leave the buffer pinned if
3148 * anyone might need it.
3149 */
3152 }
3157 /*
3158 * why is this safe?
3159 * reiserfs_setattr updates i_size in the on disk
3160 * stat data before allowing vmtruncate to be called.
3161 *
3162 * If buffer was put onto the ordered list for this
3163 * transaction, we know for sure either this transaction
3164 * or an older one already has updated i_size on disk,
3165 * and this ordered data won't be referenced in the file
3166 * if we crash.
3167 *
3168 * if the buffer was put onto the ordered list for an older
3169 * transaction, we need to leave it around
3170 */
3174 }
3175 free_jh:
3178 }
3182 }
3184 /* clm -- taken from fs/buffer.c:block_invalidate_page */
3187 {
3212 /*
3213 * is this block fully invalidated?
3214 */
3218 else
3220 }
3225 /*
3226 * We release buffers only if the entire page is being invalidated.
3227 * The get_block cached value has been unconditionally invalidated,
3228 * so real IO is not possible anymore.
3229 */
3232 /* maybe should BUG_ON(!ret); - neilb */
3233 }
3234 out:
3236 }
3239 {
3244 }
3246 }
3248 /*
3249 * Returns 1 if the page's buffers were dropped. The page is locked.
3250 *
3251 * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads
3252 * in the buffers at page_buffers(page).
3253 *
3254 * even in -o notail mode, we can't be sure an old mount without -o notail
3255 * didn't create files with tails.
3256 */
3258 {
3276 }
3277 }
3284 }
3286 /*
3287 * We thank Mingming Cao for helping us understand in great detail what
3288 * to do in this section of the code.
3289 */
3291 {
3295 ssize_t ret;
3298 reiserfs_get_blocks_direct_io);
3300 /*
3301 * In case of error extending write may have instantiated a few
3302 * blocks outside i_size. Trim these off again.
3303 */
3311 }
3312 }
3315 }
3318 {
3327 /* must be turned off for recursive notify_change calls */
3334 }
3337 /*
3338 * version 2 items will be caught by the s_maxbytes check
3339 * done for us in vmtruncate
3340 */
3346 }
3350 /* fill in hole pointers in the expanding truncate case. */
3356 /* we're changing at most 2 bitmaps, inode + super */
3361 }
3364 }
3368 }
3369 /*
3370 * file size is changed, ctime and mtime are
3371 * to be updated
3372 */
3374 }
3375 }
3381 /* stat data of format v3.5 has 16 bit uid and gid */
3384 }
3400 /*
3401 * (user+group)*(old+new) structure - we count quota
3402 * info and , inode write (sb, inode)
3403 */
3415 }
3417 /*
3418 * Update corresponding info in inode so that everything
3419 * is in one transaction
3420 */
3430 }
3436 /*
3437 * Could race against reiserfs_file_release
3438 * if called from NFS, so take tailpack mutex.
3439 */
3444 }
3445 }
3450 }
3455 }
3457 out:
3459 }
3472 };