Quelle  swapfile.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2018 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <darrick.wong@oracle.com>
 */
#include <linux/iomap.h>
#include <linux/swap.h>

/* Swapfile activation */

struct iomap_swapfile_info {
 struct iomap iomap;  /* accumulated iomap */
 struct swap_info_struct *sis;
 uint64_t lowest_ppage;  /* lowest physical addr seen (pages) */
 uint64_t highest_ppage;  /* highest physical addr seen (pages) */
 unsigned long nr_pages;  /* number of pages collected */
 int nr_extents;   /* extent count */
 struct file *file;
};

/*
 * Collect physical extents for this swap file.  Physical extents reported to
 * the swap code must be trimmed to align to a page boundary.  The logical
 * offset within the file is irrelevant since the swapfile code maps logical
 * page numbers of the swap device to the physical page-aligned extents.
 */
static int iomap_swapfile_add_extent(struct iomap_swapfile_info *isi)
{
 struct iomap *iomap = &isi->iomap;
 unsigned long nr_pages;
 unsigned long max_pages;
 uint64_t first_ppage;
 uint64_t first_ppage_reported;
 uint64_t next_ppage;
 int error;

 if (unlikely(isi->nr_pages >= isi->sis->max))
  return 0;
 max_pages = isi->sis->max - isi->nr_pages;

 /*
 * Round the start up and the end down so that the physical
 * extent aligns to a page boundary.
 */
 first_ppage = ALIGN(iomap->addr, PAGE_SIZE) >> PAGE_SHIFT;
 next_ppage = ALIGN_DOWN(iomap->addr + iomap->length, PAGE_SIZE) >>
   PAGE_SHIFT;

 /* Skip too-short physical extents. */
 if (first_ppage >= next_ppage)
  return 0;
 nr_pages = next_ppage - first_ppage;
 nr_pages = min(nr_pages, max_pages);

 /*
 * Calculate how much swap space we're adding; the first page contains
 * the swap header and doesn't count.  The mm still wants that first
 * page fed to add_swap_extent, however.
 */
 first_ppage_reported = first_ppage;
 if (iomap->offset == 0)
  first_ppage_reported++;
 if (isi->lowest_ppage > first_ppage_reported)
  isi->lowest_ppage = first_ppage_reported;
 if (isi->highest_ppage < (next_ppage - 1))
  isi->highest_ppage = next_ppage - 1;

 /* Add extent, set up for the next call. */
 error = add_swap_extent(isi->sis, isi->nr_pages, nr_pages, first_ppage);
 if (error < 0)
  return error;
 isi->nr_extents += error;
 isi->nr_pages += nr_pages;
 return 0;
}

static int iomap_swapfile_fail(struct iomap_swapfile_info *isi, const char *str)
{
 char *buf, *p = ERR_PTR(-ENOMEM);

 buf = kmalloc(PATH_MAX, GFP_KERNEL);
 if (buf)
  p = file_path(isi->file, buf, PATH_MAX);
 pr_err("swapon: file %s %s\n", IS_ERR(p) ? "" : p, str);
 kfree(buf);
 return -EINVAL;
}

/*
 * Accumulate iomaps for this swap file.  We have to accumulate iomaps because
 * swap only cares about contiguous page-aligned physical extents and makes no
 * distinction between written and unwritten extents.
 */
static int iomap_swapfile_iter(struct iomap_iter *iter,
  struct iomap *iomap, struct iomap_swapfile_info *isi)
{
 switch (iomap->type) {
 case IOMAP_MAPPED:
 case IOMAP_UNWRITTEN:
  /* Only real or unwritten extents. */
  break;
 case IOMAP_INLINE:
  /* No inline data. */
  return iomap_swapfile_fail(isi, "is inline");
 default:
  return iomap_swapfile_fail(isi, "has unallocated extents");
 }

 /* No uncommitted metadata or shared blocks. */
 if (iomap->flags & IOMAP_F_DIRTY)
  return iomap_swapfile_fail(isi, "is not committed");
 if (iomap->flags & IOMAP_F_SHARED)
  return iomap_swapfile_fail(isi, "has shared extents");

 /* Only one bdev per swap file. */
 if (iomap->bdev != isi->sis->bdev)
  return iomap_swapfile_fail(isi, "outside the main device");

 if (isi->iomap.length == 0) {
  /* No accumulated extent, so just store it. */
  memcpy(&isi->iomap, iomap, sizeof(isi->iomap));
 } else if (isi->iomap.addr + isi->iomap.length == iomap->addr) {
  /* Append this to the accumulated extent. */
  isi->iomap.length += iomap->length;
 } else {
  /* Otherwise, add the retained iomap and store this one. */
  int error = iomap_swapfile_add_extent(isi);
  if (error)
   return error;
  memcpy(&isi->iomap, iomap, sizeof(isi->iomap));
 }

 return iomap_iter_advance_full(iter);
}

/*
 * Iterate a swap file's iomaps to construct physical extents that can be
 * passed to the swapfile subsystem.
 */
int iomap_swapfile_activate(struct swap_info_struct *sis,
  struct file *swap_file, sector_t *pagespan,
  const struct iomap_ops *ops)
{
 struct inode *inode = swap_file->f_mapping->host;
 struct iomap_iter iter = {
  .inode = inode,
  .pos = 0,
  .len = ALIGN_DOWN(i_size_read(inode), PAGE_SIZE),
  .flags = IOMAP_REPORT,
 };
 struct iomap_swapfile_info isi = {
  .sis = sis,
  .lowest_ppage = (sector_t)-1ULL,
  .file = swap_file,
 };
 int ret;

 /*
 * Persist all file mapping metadata so that we won't have any
 * IOMAP_F_DIRTY iomaps.
 */
 ret = vfs_fsync(swap_file, 1);
 if (ret)
  return ret;

 while ((ret = iomap_iter(&iter, ops)) > 0)
  iter.status = iomap_swapfile_iter(&iter, &iter.iomap, &isi);
 if (ret < 0)
  return ret;

 if (isi.iomap.length) {
  ret = iomap_swapfile_add_extent(&isi);
  if (ret)
   return ret;
 }

 /*
 * If this swapfile doesn't contain even a single page-aligned
 * contiguous range of blocks, reject this useless swapfile to
 * prevent confusion later on.
 */
 if (isi.nr_pages == 0) {
  pr_warn("swapon: Cannot find a single usable page in file.\n");
  return -EINVAL;
 }

 *pagespan = 1 + isi.highest_ppage - isi.lowest_ppage;
 sis->max = isi.nr_pages;
 sis->pages = isi.nr_pages - 1;
 return isi.nr_extents;
}
EXPORT_SYMBOL_GPL(iomap_swapfile_activate);