| blob | 9e451a68580f6eef3ab4ba8c6eb729ae843d071b |
1 /*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
5 #include <linux/time.h>
6 #include <linux/reiserfs_fs.h>
7 #include <linux/reiserfs_acl.h>
8 #include <linux/reiserfs_xattr.h>
9 #include <asm/uaccess.h>
10 #include <linux/pagemap.h>
11 #include <linux/swap.h>
12 #include <linux/writeback.h>
13 #include <linux/blkdev.h>
14 #include <linux/buffer_head.h>
15 #include <linux/quotaops.h>
17 /*
18 ** We pack the tails of files on file close, not at the time they are written.
19 ** This implies an unnecessary copy of the tail and an unnecessary indirect item
20 ** insertion/balancing, for files that are written in one write.
21 ** It avoids unnecessary tail packings (balances) for files that are written in
22 ** multiple writes and are small enough to have tails.
23 **
24 ** file_release is called by the VFS layer when the file is closed. If
25 ** this is the last open file descriptor, and the file
26 ** small enough to have a tail, and the tail is currently in an
27 ** unformatted node, the tail is converted back into a direct item.
28 **
29 ** We use reiserfs_truncate_file to pack the tail, since it already has
30 ** all the conditions coded.
31 */
33 {
41 /* fast out for when nothing needs to be done */
47 }
56 /* freeing preallocation only involves relogging blocks that
57 * are already in the current transaction. preallocation gets
58 * freed at the end of each transaction, so it is impossible for
59 * us to log any additional blocks (including quota blocks)
60 */
63 /* uh oh, we can't allow the inode to go away while there
64 * is still preallocation blocks pending. Try to join the
65 * aborted transaction
66 */
71 /* hmpf, our choices here aren't good. We can pin the inode
72 * which will disallow unmount from every happening, we can
73 * do nothing, which will corrupt random memory on unmount,
74 * or we can forcibly remove the file from the preallocation
75 * list, which will leak blocks on disk. Lets pin the inode
76 * and let the admin know what is going on.
77 */
80 "pinning inode %lu because the "
84 }
85 }
88 #ifdef REISERFS_PREALLOCATE
90 #endif
93 /* copy back the error code from journal_begin */
100 /* if regular file is released by last holder and it has been
101 appended (we append by unformatted node only) or its direct
102 item(s) had to be converted, then it may have to be
103 indirect2direct converted */
105 }
106 out:
111 }
114 {
123 }
126 {
128 }
130 /* Sync a reiserfs file. */
132 /*
133 * FIXME: sync_mapping_buffers() never has anything to sync. Can
134 * be removed...
135 */
139 {
154 }
156 /* I really do not want to play with memory shortage right now, so
157 to simplify the code, we are not going to write more than this much pages at
158 a time. This still should considerably improve performance compared to 4k
159 at a time case. This is 32 pages of 4k size. */
160 #define REISERFS_WRITE_PAGES_AT_A_TIME (128 * 1024) / PAGE_CACHE_SIZE
162 /* Allocates blocks for a file to fulfil write request.
163 Maps all unmapped but prepared pages from the list.
164 Updates metadata with newly allocated blocknumbers as needed */
165 static int reiserfs_allocate_blocks_for_region(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode we work with */
168 to touch */
171 prepared pages
172 */
174 need to allocate to
175 fit the data into file
176 */
177 )
178 {
184 b_blocknr_t *allocated_blocks; // Pointer to a place where allocated blocknumbers would be stored.
191 // first page
192 unsigned int to = ((pos + write_bytes - 1) & (PAGE_CACHE_SIZE - 1)) + 1; /* last modified byte offset in last page */
195 // of the fact that we already prepared
196 // current block for journal
201 /* only preallocate if this is a small write */
204 blocks_to_allocate <
206 will_prealloc =
214 /* First we compose a key to point at the writing position, we want to do
215 that outside of any locking region. */
218 /* If we came here, it means we absolutely need to open a transaction,
219 since we need to allocate some blocks */
221 res = journal_begin(th, inode->i_sb, JOURNAL_PER_BALANCE_CNT * 3 + 1 + 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb)); // Wish I know if this number enough
226 /* Look for the in-tree position of our write, need path for block allocator */
231 }
233 /* Allocate blocks */
234 /* First fill in "hint" structure for block allocator */
236 hint.path = &path; // Path, so that block allocator can determine packing locality or whatever it needs to determine.
240 hint.block = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); // Number of disk blocks this file occupies already.
244 /* Call block allocator to allocate blocks */
245 res =
250 /* We flush the transaction in case of no space. This way some
251 blocks might become free */
257 /* We might have scheduled, so search again */
258 res =
264 }
266 /* update changed info for hint structure. */
267 res =
269 blocks_to_allocate,
270 blocks_to_allocate);
275 }
280 }
281 }
282 #ifdef __BIG_ENDIAN
283 // Too bad, I have not found any way to convert a given region from
284 // cpu format to little endian format
285 {
289 }
290 #endif
292 /* Blocks allocating well might have scheduled and tree might have changed,
293 let's search the tree again */
294 /* find where in the tree our write should go */
299 }
305 /* Let's see what we have found */
307 might need to append file with holes
308 first */
309 // Since we are writing past the file's end, we need to find out if
310 // there is a hole that needs to be inserted before our writing
311 // position, and how many blocks it is going to cover (we need to
312 // populate pointers to file blocks representing the hole with zeros)
314 {
316 /*
317 * if ih is stat data, its offset is 0 and we don't want to
318 * add 1 to pos in the hole_size calculation
319 */
323 (le_key_k_offset
326 inode->
327 i_sb->
328 s_blocksize)))
330 }
333 int to_paste = min_t(__u64, hole_size, MAX_ITEM_LEN(inode->i_sb->s_blocksize) / UNFM_P_SIZE); // How much data to insert first time.
334 /* area filled with zeroes, to supply as list of zero blocknumbers
335 We allocate it outside of loop just in case loop would spin for
336 several iterations. */
337 char *zeros = kzalloc(to_paste * UNFM_P_SIZE, GFP_ATOMIC); // We cannot insert more than MAX_ITEM_LEN bytes anyway.
341 }
343 to_paste =
346 s_blocksize) /
347 UNFM_P_SIZE);
349 /* Ok, there is existing indirect item already. Need to append it */
350 /* Calculate position past inserted item */
352 le_key_k_offset
353 (get_inode_item_key_version
357 inode->
358 i_sb->
359 s_blocksize),
361 res =
364 inode,
366 zeros,
367 UNFM_P_SIZE
368 *
369 to_paste);
373 }
375 /* No existing item, create it */
376 /* item head for new item */
379 /* create a key for our new item */
383 /* Create new item head for our new item */
386 TYPE_INDIRECT,
387 to_paste *
388 UNFM_P_SIZE,
391 /* Find where such item should live in the tree */
392 res =
396 /* item should not exist, otherwise we have error */
399 i_sb,
402 res);
403 }
407 }
408 res =
411 inode,
417 }
421 }
422 /* Now we want to check if transaction is too full, and if it is
423 we restart it. This will also free the path. */
428 res =
435 }
436 }
438 /* Well, need to recalculate path and stuff */
442 i_blkbits));
443 res =
450 }
457 }
458 }
459 // Go through existing indirect items first
460 // replace all zeroes with blocknumbers from list
461 // Note that if no corresponding item was found, by previous search,
462 // it means there are no existing in-tree representation for file area
463 // we are going to overwrite, so there is nothing to scan through for holes.
466 retry:
469 /* We run out of data in this indirect item, let's look for another
470 one. */
471 /* First if we are already modifying current item, log it */
475 }
476 /* Then set the key to look for a new indirect item (offset of old
477 item is added to old item length */
479 le_key_k_offset
484 s_blocksize));
485 /* Search ofor position of new key in the tree. */
486 res =
492 }
498 }
499 /* Ok, we have correct position in item now, so let's see if it is
500 representing file hole (blocknumber is zero) and fill it if needed */
502 /* Ok, a hole. Now we need to check if we already prepared this
503 block to be journaled */
505 /* Well, this item is not journaled yet, so we must prepare
506 it for journal first, before we can change it */
508 // here to detect if fs changed under
509 // us while we were preparing for
510 // journal.
512 // changes fs under our feet
516 reiserfs_prepare_for_journal(inode->i_sb, bh, 1); // Prepare a buffer within which indirect item is stored for changing.
519 // Sigh, fs was changed under us, we need to look for new
520 // location of item we are working with
522 /* unmark prepaerd area as journaled and search for it's
523 new position */
525 i_sb,
526 bh);
527 res =
529 i_sb,
535 }
541 }
543 }
545 curr_block++;
546 }
547 itempos++;
548 }
551 // was modified, but not logged yet.
553 }
556 // Oh, well need to append to indirect item, or to create indirect item
557 // if there weren't any
559 // Existing indirect item - append. First calculate key for append
560 // position. We do not need to recalculate path as it should
561 // already point to correct place.
569 res =
572 curr_block),
573 UNFM_P_SIZE *
575 curr_block));
578 }
580 // Last found item was statdata. That means we need to create indirect item.
583 /* create a key for our new item */
585 // because that's
586 // where first
587 // indirect item
588 // begins
589 /* Create new item head for our new item */
591 TYPE_INDIRECT,
595 /* Find where such item should live in the tree */
598 /* Well, if we have found such item already, or some error
599 occured, we need to warn user and return error */
602 "green-9009: search_by_key (%K) "
604 res);
605 }
608 }
609 /* Insert item into the tree with the data as its body */
610 res =
612 inode,
614 curr_block));
619 }
620 }
621 // the caller is responsible for closing the transaction
622 // unless we return an error, they are also responsible for logging
623 // the inode.
624 //
626 /*
627 * cleanup prellocation from previous writes
628 * if this is a partial block write
629 */
634 // go through all the pages/buffers and map the buffers to newly allocated
635 // blocks (so that system knows where to write these pages later).
646 /* For each buffer in page */
654 /* if this buffer is before requested data to map, skip it */
657 /* If this buffer is after requested data to map, abort
658 processing of current page */
665 curr_block++;
667 }
668 }
669 }
677 // Need to deal with transaction here.
678 error_exit_free_blocks:
680 // free blocks
685 error_exit:
688 // update any changes we made to blk count
690 err =
696 }
701 }
703 /* Unlock pages prepared by reiserfs_prepare_file_region_for_write */
706 {
715 }
716 }
718 /* This function will copy data from userspace to specified pages within
719 supplied byte range */
724 array to
725 prepared pages
726 */
728 data */
729 )
730 {
737 size_t count = min_t(size_t, PAGE_CACHE_SIZE - offset, write_bytes); // How much of bytes to write to this page
742 /* Copy data from userspace to the current page */
745 /* Flush processor's dcache for this page */
753 }
756 }
758 /* taken fs/buffer.c:__block_commit_write */
761 {
783 }
801 /* do data=ordered on any page past the end
802 * of file and any buffer marked BH_New.
803 */
807 }
808 }
809 }
810 }
813 drop_write_lock:
815 }
816 /*
817 * If this is a partial write which happened to make all buffers
818 * uptodate then we can optimize away a bogus readpage() for
819 * the next read(). Here we 'discover' whether the page went
820 * uptodate as a result of this (potentially partial) write.
821 */
825 }
827 /* Submit pages for write. This was separated from actual file copying
828 because we might want to allocate block numbers in-between.
829 This function assumes that caller will adjust file size to correct value. */
830 static int reiserfs_submit_file_region_for_write(struct reiserfs_transaction_handle *th, struct inode *inode, loff_t pos, /* Writing position offset */
834 )
835 {
845 int count = min_t(int, PAGE_CACHE_SIZE - offset, write_bytes); // How much of bytes to write to this page
848 status =
852 // submit all the pages even if there was error.
853 // we only remember error status to report it on
854 // exit.
856 }
857 /* now that we've gotten all the ordered buffers marked dirty,
858 * we can safely update i_size and close any running transaction
859 */
862 /* If the file have grown so much that tail packing is no
863 * longer possible, reset "need to pack" flag */
877 // this sets the proper flags for O_SYNC to trigger a commit
885 }
888 }
897 }
900 /*
901 * we have to unlock the pages after updating i_size, otherwise
902 * we race with writepage
903 */
909 }
911 }
913 /* Look if passed writing region is going to touch file's tail
914 (if it is present). And if it is, convert the tail to unformatted node */
918 )
919 {
925 // This can be int just because tails are created
926 // only for small files.
928 /* this embodies a dependency on a particular tail policy */
930 /* such a big files do not have tails, so we won't bother ourselves
931 to look for tails, simply return */
933 }
936 /* find the item containing the last byte to be written, or if
937 * writing past the end of the file then the last item of the
938 * file (and then we check its type). */
945 }
949 /* Ok, closest item is file tail (tails are stored in "direct"
950 * items), so we need to unpack it. */
951 /* To not overcomplicate matters, we just call generic_cont_expand
952 which will in turn call other stuff and finally will boil down to
953 reiserfs_get_block() that would do necessary conversion. */
954 cont_expand_offset =
964 }
966 /* This function locks pages starting from @pos for @inode.
967 @num_pages pages are locked and stored in
968 @prepared_pages array. Also buffers are allocated for these pages.
969 First and last page of the region is read if it is overwritten only
970 partially. If last page did not exist before write (file hole or file
971 append), it is zeroed, then.
972 Returns number of unallocated blocks that should be allocated to cover
973 new file data.*/
978 prepare */
980 overwritten from
981 @pos */
983 where to store
984 prepared pages */
985 )
986 {
991 /* offset of last modified byte in last
992 page */
997 // of a page.
999 // buffer in the page.
1001 // Page appeared to be not up
1002 // to date. Note how we have
1003 // at most 2 buffers, this is
1004 // because we at most may
1005 // partially overwrite two
1006 // buffers for one page. One at // the beginning of write area
1007 // and one at the end.
1008 // Everything inthe middle gets // overwritten totally.
1012 struct buffer_head *itembuf = NULL; // Buffer head that contains items that we are going to deal with
1019 "green-9001: reiserfs_prepare_file_region_for_write "
1022 }
1024 /* We have 2 loops for pages. In first loop we grab and lock the pages, so
1025 that nobody would touch these until we release the pages. Then
1026 we'd start to deal with mapping buffers to blocks. */
1032 }
1036 }
1038 /* Let's count amount of blocks for a case where all the blocks
1039 overwritten are new (we will substract already allocated blocks later) */
1041 /* These are full-overwritten pages so we count all the blocks in
1042 these pages are counted as needed to be allocated */
1043 blocks =
1046 /* count blocks needed for first page (possibly partially written) */
1047 blocks += ((PAGE_CACHE_SIZE - from) >> inode->i_blkbits) + !!(from & (inode->i_sb->s_blocksize - 1)); /* roundup */
1049 /* Now we account for last page. If last page == first page (we
1050 overwrite only one page), we substract all the blocks past the
1051 last writing position in a page out of already calculated number
1052 of blocks */
1055 /* Note how we do not roundup here since partial blocks still
1056 should be allocated */
1058 /* Now if all the write area lies past the file end, no point in
1059 maping blocks, since there is none, so we just zero out remaining
1060 parts of first and last pages in write area (if needed) */
1069 /* Since all blocks are new - use already calculated value */
1071 }
1073 /* Well, since we write somewhere into the middle of a file, there is
1074 possibility we are writing over some already allocated blocks, so
1075 let's map these blocks and substract number of such blocks out of blocks
1076 we need to allocate (calculated above) */
1077 /* Mask write position to start on blocksize, we do it out of the
1078 loop for performance reasons */
1080 /* Set cpu key to the starting position in a file (on left block boundary) */
1089 /* For each buffer in the page */
1095 /* Find where this buffer ends */
1098 /* if this buffer is before requested data to map, skip it */
1102 /* If this buffer is after requested data to map, abort
1103 processing of current page */
1105 }
1108 /* This is optimisation for a case where buffer is mapped
1109 and have blocknumber assigned. In case significant amount
1110 of such buffers are present, we may avoid some amount
1111 of search_by_key calls.
1112 Probably it would be possible to move parts of this code
1113 out of BKL, but I afraid that would overcomplicate code
1114 without any noticeable benefit.
1115 */
1116 item_pos++;
1117 /* Update the key */
1122 // allocated
1124 }
1128 current unformatted_item */
1129 /* Try to find next item */
1130 res =
1133 /* Abort if no more items */
1135 /* make sure later loops don't use this item */
1139 }
1141 /* Update information about current indirect item */
1149 }
1151 /* See if there is some block associated with the file
1152 at that position, map the buffer to this block */
1157 // allocated
1158 }
1159 item_pos++;
1160 /* Update the key */
1164 }
1165 }
1169 /* Now zero out unmappend buffers for the first and last pages of
1170 write area or issue read requests if page is mapped. */
1171 /* First page, see if it is not uptodate */
1175 /* For each buffer in page */
1182 /* Find where this buffer ends */
1185 /* if this buffer is before requested data to map, skip it */
1189 issue READ request for it to
1190 not loose data */
1195 block_start,
1198 }
1199 }
1200 }
1201 }
1203 /* Last page, see if it is not uptodate, or if the last page is past the end of the file. */
1209 /* for each buffer in page */
1216 /* Find where this buffer ends */
1219 /* if this buffer is after requested data to map, skip it */
1223 issue READ request for it to
1224 not loose data */
1231 }
1232 }
1233 }
1234 }
1236 /* Wait for read requests we made to happen, if necessary */
1242 }
1243 }
1246 failed_page_grabbing:
1248 failed_read:
1251 }
1253 /* Write @count bytes at position @ppos in a file indicated by @file
1254 from the buffer @buf.
1256 generic_file_write() is only appropriate for filesystems that are not seeking to optimize performance and want
1257 something simple that works. It is not for serious use by general purpose filesystems, excepting the one that it was
1258 written for (ext2/3). This is for several reasons:
1260 * It has no understanding of any filesystem specific optimizations.
1262 * It enters the filesystem repeatedly for each page that is written.
1264 * It depends on reiserfs_get_block() function which if implemented by reiserfs performs costly search_by_key
1265 * operation for each page it is supplied with. By contrast reiserfs_file_write() feeds as much as possible at a time
1266 * to reiserfs which allows for fewer tree traversals.
1268 * Each indirect pointer insertion takes a lot of cpu, because it involves memory moves inside of blocks.
1270 * Asking the block allocation code for blocks one at a time is slightly less efficient.
1272 All of these reasons for not using only generic file write were understood back when reiserfs was first miscoded to
1273 use it, but we were in a hurry to make code freeze, and so it couldn't be revised then. This new code should make
1274 things right finally.
1276 Future Features: providing search_by_key with hints.
1278 */
1279 static ssize_t reiserfs_file_write(struct file *file, /* the file we are going to write into */
1281 (in userspace) */
1284 * new current position before returning. */
1285 )
1286 {
1291 struct inode *inode = file->f_path.dentry->d_inode; // Inode of the file that we are writing to.
1292 /* To simplify coding at this time, we store
1293 locked pages in array for now */
1298 /* If a filesystem is converted from 3.5 to 3.6, we'll have v3.5 items
1299 * lying around (most of the disk, in fact). Despite the filesystem
1300 * now being a v3.6 format, the old items still can't support large
1301 * file sizes. Catch this case here, as the rest of the VFS layer is
1302 * oblivious to the different limitations between old and new items.
1303 * reiserfs_setattr catches this for truncates. This chunk is lifted
1304 * from generic_write_checks. */
1310 }
1313 }
1328 /* Check if we can write to specified region of file, file
1329 is not overly big and this kind of stuff. Adjust pos and
1330 count, if needed */
1344 // Ok, we are done with all the checks.
1346 // Now we should start real work
1348 /* If we are going to write past the file's packed tail or if we are going
1349 to overwrite part of the tail, we need that tail to be converted into
1350 unformatted node */
1356 /* This is the main loop in which we running until some error occures
1357 or until we write all of the data. */
1362 /* (pos & (PAGE_CACHE_SIZE-1)) is an idiom for offset into a page of pos */
1364 pages */
1367 /* convert size to amount of
1368 pages */
1372 /* If we were asked to write more data than we want to or if there
1373 is not that much space, then we shorten amount of data to write
1374 for this iteration. */
1375 num_pages =
1378 /* Also we should not forget to set size in bytes accordingly */
1381 /* If position is not on the
1382 start of the page, we need
1383 to substract the offset
1384 within page */
1388 /* reserve the blocks to be allocated later, so that later on
1389 we still have the space to write the blocks to */
1391 num_pages <<
1402 }
1403 // Otherwise we are possibly overwriting the file, so
1404 // let's set write size to be equal or less than blocksize.
1405 // This way we get it correctly for file holes.
1406 // But overwriting files on absolutelly full volumes would not
1407 // be very efficient. Well, people are not supposed to fill
1408 // 100% of disk space anyway.
1409 write_bytes =
1414 // No blocks were claimed before, so do it now.
1417 (PAGE_CACHE_SHIFT
1418 -
1419 inode->
1420 i_blkbits));
1421 }
1423 /* Prepare for writing into the region, read in all the
1424 partially overwritten pages, if needed. And lock the pages,
1425 so that nobody else can access these until we are done.
1426 We get number of actual blocks needed as a result. */
1428 num_pages,
1429 write_bytes,
1430 prepared_pages);
1433 num_pages <<
1437 }
1441 /* First we correct our estimate of how many blocks we need */
1446 s_blocksize_bits)) -
1447 blocks_to_allocate);
1450 /* Fill in all the possible holes and append the file if needed */
1451 res =
1453 num_pages,
1454 write_bytes,
1455 prepared_pages,
1456 blocks_to_allocate);
1457 }
1459 /* well, we have allocated the blocks, so it is time to free
1460 the reservation we made earlier. */
1462 blocks_to_allocate);
1466 }
1468 /* NOTE that allocating blocks and filling blocks can be done in reverse order
1469 and probably we would do that just to get rid of garbage in files after a
1470 crash */
1472 /* Copy data from user-supplied buffer to file's pages */
1473 res =
1475 write_bytes,
1480 }
1482 /* Send the pages to disk and unlock them. */
1483 res =
1485 num_pages,
1486 write_bytes,
1487 prepared_pages);
1496 }
1498 /* this is only true on error */
1506 }
1507 }
1518 out:
1521 }
1527 #ifdef CONFIG_COMPAT
1529 #endif
1539 };
1549 };