* [linux-next:master 1478/2075] fs/btrfs/fiemap.c:822:26: warning: 'last_extent_end' may be used uninitialized
@ 2024-05-28 13:15 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2024-05-28 13:15 UTC (permalink / raw)
To: Filipe Manana
Cc: oe-kbuild-all, Linux Memory Management List, David Sterba,
Johannes Thumshirn
tree: https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git master
head: 6dc544b66971c7f9909ff038b62149105272d26a
commit: 827308f8ead0e75a04ee3a5c2f47b84c67decfb2 [1478/2075] btrfs: move fiemap code into its own file
config: mips-buildonly-randconfig-r002-20221001 (https://download.01.org/0day-ci/archive/20240528/202405282148.jaF0FLhu-lkp@intel.com/config)
compiler: mips64-linux-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240528/202405282148.jaF0FLhu-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202405282148.jaF0FLhu-lkp@intel.com/
Note: it may well be a FALSE warning. FWIW you are at least aware of it now.
http://gcc.gnu.org/wiki/Better_Uninitialized_Warnings
All warnings (new ones prefixed by >>):
fs/btrfs/fiemap.c: In function 'extent_fiemap':
>> fs/btrfs/fiemap.c:822:26: warning: 'last_extent_end' may be used uninitialized [-Wmaybe-uninitialized]
822 | if (cache.cached && cache.offset + cache.len >= last_extent_end) {
| ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/btrfs/fiemap.c:640:13: note: 'last_extent_end' was declared here
640 | u64 last_extent_end;
| ^~~~~~~~~~~~~~~
vim +/last_extent_end +822 fs/btrfs/fiemap.c
629
630 static int extent_fiemap(struct btrfs_inode *inode,
631 struct fiemap_extent_info *fieinfo,
632 u64 start, u64 len)
633 {
634 const u64 ino = btrfs_ino(inode);
635 struct extent_state *cached_state = NULL;
636 struct extent_state *delalloc_cached_state = NULL;
637 struct btrfs_path *path;
638 struct fiemap_cache cache = { 0 };
639 struct btrfs_backref_share_check_ctx *backref_ctx;
640 u64 last_extent_end;
641 u64 prev_extent_end;
642 u64 range_start;
643 u64 range_end;
644 const u64 sectorsize = inode->root->fs_info->sectorsize;
645 bool stopped = false;
646 int ret;
647
648 cache.entries_size = PAGE_SIZE / sizeof(struct btrfs_fiemap_entry);
649 cache.entries = kmalloc_array(cache.entries_size,
650 sizeof(struct btrfs_fiemap_entry),
651 GFP_KERNEL);
652 backref_ctx = btrfs_alloc_backref_share_check_ctx();
653 path = btrfs_alloc_path();
654 if (!cache.entries || !backref_ctx || !path) {
655 ret = -ENOMEM;
656 goto out;
657 }
658
659 restart:
660 range_start = round_down(start, sectorsize);
661 range_end = round_up(start + len, sectorsize);
662 prev_extent_end = range_start;
663
664 lock_extent(&inode->io_tree, range_start, range_end, &cached_state);
665
666 ret = fiemap_find_last_extent_offset(inode, path, &last_extent_end);
667 if (ret < 0)
668 goto out_unlock;
669 btrfs_release_path(path);
670
671 path->reada = READA_FORWARD;
672 ret = fiemap_search_slot(inode, path, range_start);
673 if (ret < 0) {
674 goto out_unlock;
675 } else if (ret > 0) {
676 /*
677 * No file extent item found, but we may have delalloc between
678 * the current offset and i_size. So check for that.
679 */
680 ret = 0;
681 goto check_eof_delalloc;
682 }
683
684 while (prev_extent_end < range_end) {
685 struct extent_buffer *leaf = path->nodes[0];
686 struct btrfs_file_extent_item *ei;
687 struct btrfs_key key;
688 u64 extent_end;
689 u64 extent_len;
690 u64 extent_offset = 0;
691 u64 extent_gen;
692 u64 disk_bytenr = 0;
693 u64 flags = 0;
694 int extent_type;
695 u8 compression;
696
697 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
698 if (key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY)
699 break;
700
701 extent_end = btrfs_file_extent_end(path);
702
703 /*
704 * The first iteration can leave us at an extent item that ends
705 * before our range's start. Move to the next item.
706 */
707 if (extent_end <= range_start)
708 goto next_item;
709
710 backref_ctx->curr_leaf_bytenr = leaf->start;
711
712 /* We have in implicit hole (NO_HOLES feature enabled). */
713 if (prev_extent_end < key.offset) {
714 const u64 hole_end = min(key.offset, range_end) - 1;
715
716 ret = fiemap_process_hole(inode, fieinfo, &cache,
717 &delalloc_cached_state,
718 backref_ctx, 0, 0, 0,
719 prev_extent_end, hole_end);
720 if (ret < 0) {
721 goto out_unlock;
722 } else if (ret > 0) {
723 /* fiemap_fill_next_extent() told us to stop. */
724 stopped = true;
725 break;
726 }
727
728 /* We've reached the end of the fiemap range, stop. */
729 if (key.offset >= range_end) {
730 stopped = true;
731 break;
732 }
733 }
734
735 extent_len = extent_end - key.offset;
736 ei = btrfs_item_ptr(leaf, path->slots[0],
737 struct btrfs_file_extent_item);
738 compression = btrfs_file_extent_compression(leaf, ei);
739 extent_type = btrfs_file_extent_type(leaf, ei);
740 extent_gen = btrfs_file_extent_generation(leaf, ei);
741
742 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
743 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
744 if (compression == BTRFS_COMPRESS_NONE)
745 extent_offset = btrfs_file_extent_offset(leaf, ei);
746 }
747
748 if (compression != BTRFS_COMPRESS_NONE)
749 flags |= FIEMAP_EXTENT_ENCODED;
750
751 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
752 flags |= FIEMAP_EXTENT_DATA_INLINE;
753 flags |= FIEMAP_EXTENT_NOT_ALIGNED;
754 ret = emit_fiemap_extent(fieinfo, &cache, key.offset, 0,
755 extent_len, flags);
756 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
757 ret = fiemap_process_hole(inode, fieinfo, &cache,
758 &delalloc_cached_state,
759 backref_ctx,
760 disk_bytenr, extent_offset,
761 extent_gen, key.offset,
762 extent_end - 1);
763 } else if (disk_bytenr == 0) {
764 /* We have an explicit hole. */
765 ret = fiemap_process_hole(inode, fieinfo, &cache,
766 &delalloc_cached_state,
767 backref_ctx, 0, 0, 0,
768 key.offset, extent_end - 1);
769 } else {
770 /* We have a regular extent. */
771 if (fieinfo->fi_extents_max) {
772 ret = btrfs_is_data_extent_shared(inode,
773 disk_bytenr,
774 extent_gen,
775 backref_ctx);
776 if (ret < 0)
777 goto out_unlock;
778 else if (ret > 0)
779 flags |= FIEMAP_EXTENT_SHARED;
780 }
781
782 ret = emit_fiemap_extent(fieinfo, &cache, key.offset,
783 disk_bytenr + extent_offset,
784 extent_len, flags);
785 }
786
787 if (ret < 0) {
788 goto out_unlock;
789 } else if (ret > 0) {
790 /* emit_fiemap_extent() told us to stop. */
791 stopped = true;
792 break;
793 }
794
795 prev_extent_end = extent_end;
796 next_item:
797 if (fatal_signal_pending(current)) {
798 ret = -EINTR;
799 goto out_unlock;
800 }
801
802 ret = fiemap_next_leaf_item(inode, path);
803 if (ret < 0) {
804 goto out_unlock;
805 } else if (ret > 0) {
806 /* No more file extent items for this inode. */
807 break;
808 }
809 cond_resched();
810 }
811
812 check_eof_delalloc:
813 if (!stopped && prev_extent_end < range_end) {
814 ret = fiemap_process_hole(inode, fieinfo, &cache,
815 &delalloc_cached_state, backref_ctx,
816 0, 0, 0, prev_extent_end, range_end - 1);
817 if (ret < 0)
818 goto out_unlock;
819 prev_extent_end = range_end;
820 }
821
> 822 if (cache.cached && cache.offset + cache.len >= last_extent_end) {
823 const u64 i_size = i_size_read(&inode->vfs_inode);
824
825 if (prev_extent_end < i_size) {
826 u64 delalloc_start;
827 u64 delalloc_end;
828 bool delalloc;
829
830 delalloc = btrfs_find_delalloc_in_range(inode,
831 prev_extent_end,
832 i_size - 1,
833 &delalloc_cached_state,
834 &delalloc_start,
835 &delalloc_end);
836 if (!delalloc)
837 cache.flags |= FIEMAP_EXTENT_LAST;
838 } else {
839 cache.flags |= FIEMAP_EXTENT_LAST;
840 }
841 }
842
843 out_unlock:
844 unlock_extent(&inode->io_tree, range_start, range_end, &cached_state);
845
846 if (ret == BTRFS_FIEMAP_FLUSH_CACHE) {
847 btrfs_release_path(path);
848 ret = flush_fiemap_cache(fieinfo, &cache);
849 if (ret)
850 goto out;
851 len -= cache.next_search_offset - start;
852 start = cache.next_search_offset;
853 goto restart;
854 } else if (ret < 0) {
855 goto out;
856 }
857
858 /*
859 * Must free the path before emitting to the fiemap buffer because we
860 * may have a non-cloned leaf and if the fiemap buffer is memory mapped
861 * to a file, a write into it (through btrfs_page_mkwrite()) may trigger
862 * waiting for an ordered extent that in order to complete needs to
863 * modify that leaf, therefore leading to a deadlock.
864 */
865 btrfs_free_path(path);
866 path = NULL;
867
868 ret = flush_fiemap_cache(fieinfo, &cache);
869 if (ret)
870 goto out;
871
872 ret = emit_last_fiemap_cache(fieinfo, &cache);
873 out:
874 free_extent_state(delalloc_cached_state);
875 kfree(cache.entries);
876 btrfs_free_backref_share_ctx(backref_ctx);
877 btrfs_free_path(path);
878 return ret;
879 }
880
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2024-05-28 13:16 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2024-05-28 13:15 [linux-next:master 1478/2075] fs/btrfs/fiemap.c:822:26: warning: 'last_extent_end' may be used uninitialized kernel test robot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox