1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2022 Fujitsu. All Rights Reserved. 4 */ 5 6 #include "xfs.h" 7 #include "xfs_shared.h" 8 #include "xfs_format.h" 9 #include "xfs_log_format.h" 10 #include "xfs_trans_resv.h" 11 #include "xfs_mount.h" 12 #include "xfs_alloc.h" 13 #include "xfs_bit.h" 14 #include "xfs_btree.h" 15 #include "xfs_inode.h" 16 #include "xfs_icache.h" 17 #include "xfs_rmap.h" 18 #include "xfs_rmap_btree.h" 19 #include "xfs_rtalloc.h" 20 #include "xfs_trans.h" 21 #include "xfs_ag.h" 22 23 #include <linux/mm.h> 24 #include <linux/dax.h> 25 26 struct xfs_failure_info { 27 xfs_agblock_t startblock; 28 xfs_extlen_t blockcount; 29 int mf_flags; 30 bool want_shutdown; 31 }; 32 33 static pgoff_t xfs_failure_pgoff(struct xfs_mount * mp,const struct xfs_rmap_irec * rec,const struct xfs_failure_info * notify)34 xfs_failure_pgoff( 35 struct xfs_mount *mp, 36 const struct xfs_rmap_irec *rec, 37 const struct xfs_failure_info *notify) 38 { 39 loff_t pos = XFS_FSB_TO_B(mp, rec->rm_offset); 40 41 if (notify->startblock > rec->rm_startblock) 42 pos += XFS_FSB_TO_B(mp, 43 notify->startblock - rec->rm_startblock); 44 return pos >> PAGE_SHIFT; 45 } 46 47 static unsigned long xfs_failure_pgcnt(struct xfs_mount * mp,const struct xfs_rmap_irec * rec,const struct xfs_failure_info * notify)48 xfs_failure_pgcnt( 49 struct xfs_mount *mp, 50 const struct xfs_rmap_irec *rec, 51 const struct xfs_failure_info *notify) 52 { 53 xfs_agblock_t end_rec; 54 xfs_agblock_t end_notify; 55 xfs_agblock_t start_cross; 56 xfs_agblock_t end_cross; 57 58 start_cross = max(rec->rm_startblock, notify->startblock); 59 60 end_rec = rec->rm_startblock + rec->rm_blockcount; 61 end_notify = notify->startblock + notify->blockcount; 62 end_cross = min(end_rec, end_notify); 63 64 return XFS_FSB_TO_B(mp, end_cross - start_cross) >> PAGE_SHIFT; 65 } 66 67 static int xfs_dax_failure_fn(struct xfs_btree_cur * cur,const struct xfs_rmap_irec * rec,void * data)68 xfs_dax_failure_fn( 69 struct xfs_btree_cur *cur, 70 const struct xfs_rmap_irec *rec, 71 void *data) 72 { 73 struct xfs_mount *mp = cur->bc_mp; 74 struct xfs_inode *ip; 75 struct xfs_failure_info *notify = data; 76 int error = 0; 77 78 if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) || 79 (rec->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))) { 80 notify->want_shutdown = true; 81 return 0; 82 } 83 84 /* Get files that incore, filter out others that are not in use. */ 85 error = xfs_iget(mp, cur->bc_tp, rec->rm_owner, XFS_IGET_INCORE, 86 0, &ip); 87 /* Continue the rmap query if the inode isn't incore */ 88 if (error == -ENODATA) 89 return 0; 90 if (error) { 91 notify->want_shutdown = true; 92 return 0; 93 } 94 95 error = mf_dax_kill_procs(VFS_I(ip)->i_mapping, 96 xfs_failure_pgoff(mp, rec, notify), 97 xfs_failure_pgcnt(mp, rec, notify), 98 notify->mf_flags); 99 xfs_irele(ip); 100 return error; 101 } 102 103 static int xfs_dax_notify_ddev_failure(struct xfs_mount * mp,xfs_daddr_t daddr,xfs_daddr_t bblen,int mf_flags)104 xfs_dax_notify_ddev_failure( 105 struct xfs_mount *mp, 106 xfs_daddr_t daddr, 107 xfs_daddr_t bblen, 108 int mf_flags) 109 { 110 struct xfs_failure_info notify = { .mf_flags = mf_flags }; 111 struct xfs_trans *tp = NULL; 112 struct xfs_btree_cur *cur = NULL; 113 struct xfs_buf *agf_bp = NULL; 114 int error = 0; 115 xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, daddr); 116 xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, fsbno); 117 xfs_fsblock_t end_fsbno = XFS_DADDR_TO_FSB(mp, 118 daddr + bblen - 1); 119 xfs_agnumber_t end_agno = XFS_FSB_TO_AGNO(mp, end_fsbno); 120 121 error = xfs_trans_alloc_empty(mp, &tp); 122 if (error) 123 return error; 124 125 for (; agno <= end_agno; agno++) { 126 struct xfs_rmap_irec ri_low = { }; 127 struct xfs_rmap_irec ri_high; 128 struct xfs_agf *agf; 129 struct xfs_perag *pag; 130 xfs_agblock_t range_agend; 131 132 pag = xfs_perag_get(mp, agno); 133 error = xfs_alloc_read_agf(pag, tp, 0, &agf_bp); 134 if (error) { 135 xfs_perag_put(pag); 136 break; 137 } 138 139 cur = xfs_rmapbt_init_cursor(mp, tp, agf_bp, pag); 140 141 /* 142 * Set the rmap range from ri_low to ri_high, which represents 143 * a [start, end] where we looking for the files or metadata. 144 */ 145 memset(&ri_high, 0xFF, sizeof(ri_high)); 146 ri_low.rm_startblock = XFS_FSB_TO_AGBNO(mp, fsbno); 147 if (agno == end_agno) 148 ri_high.rm_startblock = XFS_FSB_TO_AGBNO(mp, end_fsbno); 149 150 agf = agf_bp->b_addr; 151 range_agend = min(be32_to_cpu(agf->agf_length) - 1, 152 ri_high.rm_startblock); 153 notify.startblock = ri_low.rm_startblock; 154 notify.blockcount = range_agend + 1 - ri_low.rm_startblock; 155 156 error = xfs_rmap_query_range(cur, &ri_low, &ri_high, 157 xfs_dax_failure_fn, ¬ify); 158 xfs_btree_del_cursor(cur, error); 159 xfs_trans_brelse(tp, agf_bp); 160 xfs_perag_put(pag); 161 if (error) 162 break; 163 164 fsbno = XFS_AGB_TO_FSB(mp, agno + 1, 0); 165 } 166 167 xfs_trans_cancel(tp); 168 if (error || notify.want_shutdown) { 169 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_ONDISK); 170 if (!error) 171 error = -EFSCORRUPTED; 172 } 173 return error; 174 } 175 176 static int xfs_dax_notify_failure(struct dax_device * dax_dev,u64 offset,u64 len,int mf_flags)177 xfs_dax_notify_failure( 178 struct dax_device *dax_dev, 179 u64 offset, 180 u64 len, 181 int mf_flags) 182 { 183 struct xfs_mount *mp = dax_holder(dax_dev); 184 u64 ddev_start; 185 u64 ddev_end; 186 187 if (!(mp->m_super->s_flags & SB_BORN)) { 188 xfs_warn(mp, "filesystem is not ready for notify_failure()!"); 189 return -EIO; 190 } 191 192 if (mp->m_rtdev_targp && mp->m_rtdev_targp->bt_daxdev == dax_dev) { 193 xfs_debug(mp, 194 "notify_failure() not supported on realtime device!"); 195 return -EOPNOTSUPP; 196 } 197 198 if (mp->m_logdev_targp && mp->m_logdev_targp->bt_daxdev == dax_dev && 199 mp->m_logdev_targp != mp->m_ddev_targp) { 200 xfs_err(mp, "ondisk log corrupt, shutting down fs!"); 201 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_ONDISK); 202 return -EFSCORRUPTED; 203 } 204 205 if (!xfs_has_rmapbt(mp)) { 206 xfs_debug(mp, "notify_failure() needs rmapbt enabled!"); 207 return -EOPNOTSUPP; 208 } 209 210 ddev_start = mp->m_ddev_targp->bt_dax_part_off; 211 ddev_end = ddev_start + bdev_nr_bytes(mp->m_ddev_targp->bt_bdev) - 1; 212 213 /* Ignore the range out of filesystem area */ 214 if (offset + len - 1 < ddev_start) 215 return -ENXIO; 216 if (offset > ddev_end) 217 return -ENXIO; 218 219 /* Calculate the real range when it touches the boundary */ 220 if (offset > ddev_start) 221 offset -= ddev_start; 222 else { 223 len -= ddev_start - offset; 224 offset = 0; 225 } 226 if (offset + len - 1 > ddev_end) 227 len = ddev_end - offset + 1; 228 229 return xfs_dax_notify_ddev_failure(mp, BTOBB(offset), BTOBB(len), 230 mf_flags); 231 } 232 233 const struct dax_holder_operations xfs_dax_holder_operations = { 234 .notify_failure = xfs_dax_notify_failure, 235 }; 236