From patchwork Wed Dec 10 01:45:48 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Omar Sandoval X-Patchwork-Id: 5466191 Return-Path: X-Original-To: patchwork-linux-btrfs@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 53B809F1D4 for ; Wed, 10 Dec 2014 01:47:22 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 3EE3C2017D for ; Wed, 10 Dec 2014 01:47:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 3F12620295 for ; Wed, 10 Dec 2014 01:47:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754368AbaLJBrG (ORCPT ); Tue, 9 Dec 2014 20:47:06 -0500 Received: from mail-pa0-f50.google.com ([209.85.220.50]:37959 "EHLO mail-pa0-f50.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754237AbaLJBqv (ORCPT ); Tue, 9 Dec 2014 20:46:51 -0500 Received: by mail-pa0-f50.google.com with SMTP id bj1so1730297pad.37 for ; Tue, 09 Dec 2014 17:46:49 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:in-reply-to:references; bh=jobdu43TtsqEG2baOB9iiDIPrggeTNVSPgahgLEZJy4=; b=mb5447fc79ZiQvQz84onImKrqhMX81RBOLPMLmuvT5qIZBEJ6VcfapYHUYGgVcLn3/ cgmENzOEYEkA2fkjRd63sAd60s8pGMl7YUi4QVHP/WQTE0rNN0L5ntRiZZy9OkF66AQs KV6N382IMg6/uJBy7jC2mhqsEgefwk5ZoZJqB4Liet/H2CqM0VlH2EQ4HGFFbrU6Y3TB ozQZM0TQvGm0aCS63aTkTt1XyT9jYtE5TvaUZ+Nximz6MX42Qx2h/F/qpHdJEnz0fqGW Qyzo8BkFpk0h+NoFzJyzNaIJb67kTnrG/oPYP9HA2ClG+ymahVOYzGMM6WxoEViJ0Y9T a8sQ== X-Gm-Message-State: ALoCoQlDTM3O3sSaJSa4hJwB/TrTHo8EhOLLMlOdZGU6pQG0Uok/W3L3REyxgc25Zu/I5POCUGns X-Received: by 10.68.69.109 with SMTP id d13mr2291096pbu.57.1418176009813; Tue, 09 Dec 2014 17:46:49 -0800 (PST) Received: from mew.localdomain (c-24-19-133-29.hsd1.wa.comcast.net. [24.19.133.29]) by mx.google.com with ESMTPSA id on1sm2602957pdb.32.2014.12.09.17.46.48 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 09 Dec 2014 17:46:49 -0800 (PST) From: Omar Sandoval To: Alexander Viro , Andrew Morton , Chris Mason , Josef Bacik , Trond Myklebust , Christoph Hellwig , David Sterba , linux-btrfs@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Omar Sandoval Subject: [RFC PATCH v3 7/7] btrfs: enable swap file support Date: Tue, 9 Dec 2014 17:45:48 -0800 Message-Id: <0f9937165d8fc1b8b6332ac97e59593022e9fa5b.1418173063.git.osandov@osandov.com> X-Mailer: git-send-email 2.1.3 In-Reply-To: References: In-Reply-To: References: Sender: linux-btrfs-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Implement the swap file a_ops on btrfs. Activation does two things: 1. Checks for a usable swap file: it must be fully allocated (no holes), support direct I/O (so no compressed or inline extents) and must be eligible for nocow in its entirety in order to avoid doing a bunch of allocations for a COW when we're already low on memory 2. Pins the extent maps in memory with EXTENT_FLAG_SWAPFILE Deactivation unpins all of the extent maps. Signed-off-by: Omar Sandoval --- fs/btrfs/inode.c | 131 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 7c2dfb2..76b58d7 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -7191,6 +7191,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock, * this will cow the extent, reset the len in case we changed * it above */ + WARN_ON_ONCE(IS_SWAPFILE(inode)); len = bh_result->b_size; free_extent_map(em); em = btrfs_new_extent_direct(inode, start, len); @@ -9443,6 +9444,134 @@ out_inode: } +static void __clear_swapfile_extents(struct inode *inode) +{ + u64 isize = inode->i_size; + struct extent_map *em; + u64 start, len; + + start = 0; + while (start < isize) { + len = isize - start; + em = btrfs_get_extent(inode, NULL, 0, start, len, 0); + if (IS_ERR(em)) + return; + + clear_bit(EXTENT_FLAG_SWAPFILE, &em->flags); + + start = extent_map_end(em); + free_extent_map(em); + } +} + +static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file, + sector_t *span) +{ + struct inode *inode = file_inode(file); + struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; + struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; + int ret = 0; + u64 isize = inode->i_size; + struct extent_state *cached_state = NULL; + struct extent_map *em; + u64 start, len; + + if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) { + /* Can't do direct I/O on a compressed file. */ + btrfs_err(fs_info, "swapfile is compressed"); + return -EINVAL; + } + if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) { + /* + * Going through the copy-on-write path while swapping pages + * in/out and doing a bunch of allocations could stress the + * memory management code that got us there in the first place, + * and that's sure to be a bad time. + */ + btrfs_err(fs_info, "swapfile is copy-on-write"); + return -EINVAL; + } + + lock_extent_bits(io_tree, 0, isize - 1, 0, &cached_state); + + /* + * All of the extents must be allocated and support direct I/O. Inline + * extents and compressed extents fall back to buffered I/O, so those + * are no good. Additionally, all of the extents must be safe for nocow. + */ + atomic_inc(&BTRFS_I(inode)->root->nr_swapfiles); + start = 0; + while (start < isize) { + len = isize - start; + em = btrfs_get_extent(inode, NULL, 0, start, len, 0); + if (IS_ERR(em)) { + ret = PTR_ERR(em); + goto out; + } + + if (test_bit(EXTENT_FLAG_VACANCY, &em->flags) || + em->block_start == EXTENT_MAP_HOLE) { + btrfs_err(fs_info, "swapfile has holes"); + ret = -EINVAL; + goto out; + } + if (em->block_start == EXTENT_MAP_INLINE) { + /* + * It's unlikely we'll ever actually find ourselves + * here, as a file small enough to fit inline won't be + * big enough to store more than the swap header, but in + * case something changes in the future, let's catch it + * here rather than later. + */ + btrfs_err(fs_info, "swapfile is inline"); + ret = -EINVAL; + goto out; + } + if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { + btrfs_err(fs_info, "swapfile is compresed"); + ret = -EINVAL; + goto out; + } + ret = can_nocow_extent(inode, start, &len, NULL, NULL, NULL); + if (ret < 0) { + goto out; + } else if (ret == 1) { + ret = 0; + } else { + btrfs_err(fs_info, "swapfile has extent requiring COW (%llu-%llu)", + start, start + len - 1); + ret = -EINVAL; + goto out; + } + + set_bit(EXTENT_FLAG_SWAPFILE, &em->flags); + + start = extent_map_end(em); + free_extent_map(em); + } + +out: + if (ret) { + __clear_swapfile_extents(inode); + atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles); + } + unlock_extent_cached(io_tree, 0, isize - 1, &cached_state, GFP_NOFS); + return ret; +} + +static void btrfs_swap_deactivate(struct file *file) +{ + struct inode *inode = file_inode(file); + struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; + struct extent_state *cached_state = NULL; + u64 isize = inode->i_size; + + lock_extent_bits(io_tree, 0, isize - 1, 0, &cached_state); + __clear_swapfile_extents(inode); + unlock_extent_cached(io_tree, 0, isize - 1, &cached_state, GFP_NOFS); + atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles); +} + static const struct inode_operations btrfs_dir_inode_operations = { .getattr = btrfs_getattr, .lookup = btrfs_lookup, @@ -9520,6 +9649,8 @@ static const struct address_space_operations btrfs_aops = { .releasepage = btrfs_releasepage, .set_page_dirty = btrfs_set_page_dirty, .error_remove_page = generic_error_remove_page, + .swap_activate = btrfs_swap_activate, + .swap_deactivate = btrfs_swap_deactivate, }; static const struct address_space_operations btrfs_symlink_aops = {