mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-23 23:46:09 +07:00
0b61f8a407
Remove the verbose license text from XFS files and replace them
with SPDX tags. This does not change the license of any of the code,
merely refers to the common, up-to-date license files in LICENSES/
This change was mostly scripted. fs/xfs/Makefile and
fs/xfs/libxfs/xfs_fs.h were modified by hand, the rest were detected
and modified by the following command:
for f in `git grep -l "GNU General" fs/xfs/` ; do
echo $f
cat $f | awk -f hdr.awk > $f.new
mv -f $f.new $f
done
And the hdr.awk script that did the modification (including
detecting the difference between GPL-2.0 and GPL-2.0+ licenses)
is as follows:
$ cat hdr.awk
BEGIN {
hdr = 1.0
tag = "GPL-2.0"
str = ""
}
/^ \* This program is free software/ {
hdr = 2.0;
next
}
/any later version./ {
tag = "GPL-2.0+"
next
}
/^ \*\// {
if (hdr > 0.0) {
print "// SPDX-License-Identifier: " tag
print str
print $0
str=""
hdr = 0.0
next
}
print $0
next
}
/^ \* / {
if (hdr > 1.0)
next
if (hdr > 0.0) {
if (str != "")
str = str "\n"
str = str $0
next
}
print $0
next
}
/^ \*/ {
if (hdr > 0.0)
next
print $0
next
}
// {
if (hdr > 0.0) {
if (str != "")
str = str "\n"
str = str $0
next
}
print $0
}
END { }
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
157 lines
3.9 KiB
C
157 lines
3.9 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2017 Oracle. All Rights Reserved.
|
|
* Author: Darrick J. Wong <darrick.wong@oracle.com>
|
|
*/
|
|
#include "xfs.h"
|
|
#include "xfs_fs.h"
|
|
#include "xfs_shared.h"
|
|
#include "xfs_format.h"
|
|
#include "xfs_trans_resv.h"
|
|
#include "xfs_mount.h"
|
|
#include "xfs_defer.h"
|
|
#include "xfs_btree.h"
|
|
#include "xfs_bit.h"
|
|
#include "xfs_log_format.h"
|
|
#include "xfs_trans.h"
|
|
#include "xfs_sb.h"
|
|
#include "xfs_alloc.h"
|
|
#include "xfs_rtalloc.h"
|
|
#include "xfs_inode.h"
|
|
#include "scrub/xfs_scrub.h"
|
|
#include "scrub/scrub.h"
|
|
#include "scrub/common.h"
|
|
#include "scrub/trace.h"
|
|
|
|
/* Set us up with the realtime metadata locked. */
|
|
int
|
|
xfs_scrub_setup_rt(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_inode *ip)
|
|
{
|
|
int error;
|
|
|
|
error = xfs_scrub_setup_fs(sc, ip);
|
|
if (error)
|
|
return error;
|
|
|
|
sc->ilock_flags = XFS_ILOCK_EXCL | XFS_ILOCK_RTBITMAP;
|
|
sc->ip = sc->mp->m_rbmip;
|
|
xfs_ilock(sc->ip, sc->ilock_flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Realtime bitmap. */
|
|
|
|
/* Scrub a free extent record from the realtime bitmap. */
|
|
STATIC int
|
|
xfs_scrub_rtbitmap_rec(
|
|
struct xfs_trans *tp,
|
|
struct xfs_rtalloc_rec *rec,
|
|
void *priv)
|
|
{
|
|
struct xfs_scrub_context *sc = priv;
|
|
xfs_rtblock_t startblock;
|
|
xfs_rtblock_t blockcount;
|
|
|
|
startblock = rec->ar_startext * tp->t_mountp->m_sb.sb_rextsize;
|
|
blockcount = rec->ar_extcount * tp->t_mountp->m_sb.sb_rextsize;
|
|
|
|
if (startblock + blockcount <= startblock ||
|
|
!xfs_verify_rtbno(sc->mp, startblock) ||
|
|
!xfs_verify_rtbno(sc->mp, startblock + blockcount - 1))
|
|
xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
|
|
return 0;
|
|
}
|
|
|
|
/* Scrub the realtime bitmap. */
|
|
int
|
|
xfs_scrub_rtbitmap(
|
|
struct xfs_scrub_context *sc)
|
|
{
|
|
int error;
|
|
|
|
/* Invoke the fork scrubber. */
|
|
error = xfs_scrub_metadata_inode_forks(sc);
|
|
if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
|
|
return error;
|
|
|
|
error = xfs_rtalloc_query_all(sc->tp, xfs_scrub_rtbitmap_rec, sc);
|
|
if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
|
|
goto out;
|
|
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
/* Scrub the realtime summary. */
|
|
int
|
|
xfs_scrub_rtsummary(
|
|
struct xfs_scrub_context *sc)
|
|
{
|
|
struct xfs_inode *rsumip = sc->mp->m_rsumip;
|
|
struct xfs_inode *old_ip = sc->ip;
|
|
uint old_ilock_flags = sc->ilock_flags;
|
|
int error = 0;
|
|
|
|
/*
|
|
* We ILOCK'd the rt bitmap ip in the setup routine, now lock the
|
|
* rt summary ip in compliance with the rt inode locking rules.
|
|
*
|
|
* Since we switch sc->ip to rsumip we have to save the old ilock
|
|
* flags so that we don't mix up the inode state that @sc tracks.
|
|
*/
|
|
sc->ip = rsumip;
|
|
sc->ilock_flags = XFS_ILOCK_EXCL | XFS_ILOCK_RTSUM;
|
|
xfs_ilock(sc->ip, sc->ilock_flags);
|
|
|
|
/* Invoke the fork scrubber. */
|
|
error = xfs_scrub_metadata_inode_forks(sc);
|
|
if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
|
|
goto out;
|
|
|
|
/* XXX: implement this some day */
|
|
xfs_scrub_set_incomplete(sc);
|
|
out:
|
|
/* Switch back to the rtbitmap inode and lock flags. */
|
|
xfs_iunlock(sc->ip, sc->ilock_flags);
|
|
sc->ilock_flags = old_ilock_flags;
|
|
sc->ip = old_ip;
|
|
return error;
|
|
}
|
|
|
|
|
|
/* xref check that the extent is not free in the rtbitmap */
|
|
void
|
|
xfs_scrub_xref_is_used_rt_space(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_rtblock_t fsbno,
|
|
xfs_extlen_t len)
|
|
{
|
|
xfs_rtblock_t startext;
|
|
xfs_rtblock_t endext;
|
|
xfs_rtblock_t extcount;
|
|
bool is_free;
|
|
int error;
|
|
|
|
if (xfs_scrub_skip_xref(sc->sm))
|
|
return;
|
|
|
|
startext = fsbno;
|
|
endext = fsbno + len - 1;
|
|
do_div(startext, sc->mp->m_sb.sb_rextsize);
|
|
if (do_div(endext, sc->mp->m_sb.sb_rextsize))
|
|
endext++;
|
|
extcount = endext - startext;
|
|
xfs_ilock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
|
|
error = xfs_rtalloc_extent_is_free(sc->mp, sc->tp, startext, extcount,
|
|
&is_free);
|
|
if (!xfs_scrub_should_check_xref(sc, &error, NULL))
|
|
goto out_unlock;
|
|
if (is_free)
|
|
xfs_scrub_ino_xref_set_corrupt(sc, sc->mp->m_rbmip->i_ino);
|
|
out_unlock:
|
|
xfs_iunlock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
|
|
}
|