1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2014 Christoph Hellwig. 4 */ 5 #include <linux/iomap.h> 6 #include "xfs.h" 7 #include "xfs_format.h" 8 #include "xfs_log_format.h" 9 #include "xfs_trans_resv.h" 10 #include "xfs_sb.h" 11 #include "xfs_mount.h" 12 #include "xfs_inode.h" 13 #include "xfs_trans.h" 14 #include "xfs_log.h" 15 #include "xfs_bmap.h" 16 #include "xfs_bmap_util.h" 17 #include "xfs_error.h" 18 #include "xfs_iomap.h" 19 #include "xfs_shared.h" 20 #include "xfs_bit.h" 21 #include "xfs_pnfs.h" 22 23 /* 24 * Ensure that we do not have any outstanding pNFS layouts that can be used by 25 * clients to directly read from or write to this inode. This must be called 26 * before every operation that can remove blocks from the extent map. 27 * Additionally we call it during the write operation, where aren't concerned 28 * about exposing unallocated blocks but just want to provide basic 29 * synchronization between a local writer and pNFS clients. mmap writes would 30 * also benefit from this sort of synchronization, but due to the tricky locking 31 * rules in the page fault path we don't bother. 32 */ 33 int 34 xfs_break_layouts( 35 struct inode *inode, 36 uint *iolock) 37 { 38 struct xfs_inode *ip = XFS_I(inode); 39 int error; 40 41 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)); 42 43 while ((error = break_layout(inode, false) == -EWOULDBLOCK)) { 44 xfs_iunlock(ip, *iolock); 45 error = break_layout(inode, true); 46 *iolock = XFS_IOLOCK_EXCL; 47 xfs_ilock(ip, *iolock); 48 } 49 50 return error; 51 } 52 53 /* 54 * Get a unique ID including its location so that the client can identify 55 * the exported device. 56 */ 57 int 58 xfs_fs_get_uuid( 59 struct super_block *sb, 60 u8 *buf, 61 u32 *len, 62 u64 *offset) 63 { 64 struct xfs_mount *mp = XFS_M(sb); 65 66 printk_once(KERN_NOTICE 67 "XFS (%s): using experimental pNFS feature, use at your own risk!\n", 68 mp->m_fsname); 69 70 if (*len < sizeof(uuid_t)) 71 return -EINVAL; 72 73 memcpy(buf, &mp->m_sb.sb_uuid, sizeof(uuid_t)); 74 *len = sizeof(uuid_t); 75 *offset = offsetof(struct xfs_dsb, sb_uuid); 76 return 0; 77 } 78 79 /* 80 * Get a layout for the pNFS client. 81 */ 82 int 83 xfs_fs_map_blocks( 84 struct inode *inode, 85 loff_t offset, 86 u64 length, 87 struct iomap *iomap, 88 bool write, 89 u32 *device_generation) 90 { 91 struct xfs_inode *ip = XFS_I(inode); 92 struct xfs_mount *mp = ip->i_mount; 93 struct xfs_bmbt_irec imap; 94 xfs_fileoff_t offset_fsb, end_fsb; 95 loff_t limit; 96 int bmapi_flags = XFS_BMAPI_ENTIRE; 97 int nimaps = 1; 98 uint lock_flags; 99 int error = 0; 100 101 if (XFS_FORCED_SHUTDOWN(mp)) 102 return -EIO; 103 104 /* 105 * We can't export inodes residing on the realtime device. The realtime 106 * device doesn't have a UUID to identify it, so the client has no way 107 * to find it. 108 */ 109 if (XFS_IS_REALTIME_INODE(ip)) 110 return -ENXIO; 111 112 /* 113 * The pNFS block layout spec actually supports reflink like 114 * functionality, but the Linux pNFS server doesn't implement it yet. 115 */ 116 if (xfs_is_reflink_inode(ip)) 117 return -ENXIO; 118 119 /* 120 * Lock out any other I/O before we flush and invalidate the pagecache, 121 * and then hand out a layout to the remote system. This is very 122 * similar to direct I/O, except that the synchronization is much more 123 * complicated. See the comment near xfs_break_layouts for a detailed 124 * explanation. 125 */ 126 xfs_ilock(ip, XFS_IOLOCK_EXCL); 127 128 error = -EINVAL; 129 limit = mp->m_super->s_maxbytes; 130 if (!write) 131 limit = max(limit, round_up(i_size_read(inode), 132 inode->i_sb->s_blocksize)); 133 if (offset > limit) 134 goto out_unlock; 135 if (offset > limit - length) 136 length = limit - offset; 137 138 error = filemap_write_and_wait(inode->i_mapping); 139 if (error) 140 goto out_unlock; 141 error = invalidate_inode_pages2(inode->i_mapping); 142 if (WARN_ON_ONCE(error)) 143 return error; 144 145 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + length); 146 offset_fsb = XFS_B_TO_FSBT(mp, offset); 147 148 lock_flags = xfs_ilock_data_map_shared(ip); 149 error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, 150 &imap, &nimaps, bmapi_flags); 151 xfs_iunlock(ip, lock_flags); 152 153 if (error) 154 goto out_unlock; 155 156 if (write) { 157 enum xfs_prealloc_flags flags = 0; 158 159 ASSERT(imap.br_startblock != DELAYSTARTBLOCK); 160 161 if (!nimaps || imap.br_startblock == HOLESTARTBLOCK) { 162 /* 163 * xfs_iomap_write_direct() expects to take ownership of 164 * the shared ilock. 165 */ 166 xfs_ilock(ip, XFS_ILOCK_SHARED); 167 error = xfs_iomap_write_direct(ip, offset, length, 168 &imap, nimaps); 169 if (error) 170 goto out_unlock; 171 172 /* 173 * Ensure the next transaction is committed 174 * synchronously so that the blocks allocated and 175 * handed out to the client are guaranteed to be 176 * present even after a server crash. 177 */ 178 flags |= XFS_PREALLOC_SET | XFS_PREALLOC_SYNC; 179 } 180 181 error = xfs_update_prealloc_flags(ip, flags); 182 if (error) 183 goto out_unlock; 184 } 185 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 186 187 xfs_bmbt_to_iomap(ip, iomap, &imap); 188 *device_generation = mp->m_generation; 189 return error; 190 out_unlock: 191 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 192 return error; 193 } 194 195 /* 196 * Ensure the size update falls into a valid allocated block. 197 */ 198 static int 199 xfs_pnfs_validate_isize( 200 struct xfs_inode *ip, 201 xfs_off_t isize) 202 { 203 struct xfs_bmbt_irec imap; 204 int nimaps = 1; 205 int error = 0; 206 207 xfs_ilock(ip, XFS_ILOCK_SHARED); 208 error = xfs_bmapi_read(ip, XFS_B_TO_FSBT(ip->i_mount, isize - 1), 1, 209 &imap, &nimaps, 0); 210 xfs_iunlock(ip, XFS_ILOCK_SHARED); 211 if (error) 212 return error; 213 214 if (imap.br_startblock == HOLESTARTBLOCK || 215 imap.br_startblock == DELAYSTARTBLOCK || 216 imap.br_state == XFS_EXT_UNWRITTEN) 217 return -EIO; 218 return 0; 219 } 220 221 /* 222 * Make sure the blocks described by maps are stable on disk. This includes 223 * converting any unwritten extents, flushing the disk cache and updating the 224 * time stamps. 225 * 226 * Note that we rely on the caller to always send us a timestamp update so that 227 * we always commit a transaction here. If that stops being true we will have 228 * to manually flush the cache here similar to what the fsync code path does 229 * for datasyncs on files that have no dirty metadata. 230 */ 231 int 232 xfs_fs_commit_blocks( 233 struct inode *inode, 234 struct iomap *maps, 235 int nr_maps, 236 struct iattr *iattr) 237 { 238 struct xfs_inode *ip = XFS_I(inode); 239 struct xfs_mount *mp = ip->i_mount; 240 struct xfs_trans *tp; 241 bool update_isize = false; 242 int error, i; 243 loff_t size; 244 245 ASSERT(iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME)); 246 247 xfs_ilock(ip, XFS_IOLOCK_EXCL); 248 249 size = i_size_read(inode); 250 if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size > size) { 251 update_isize = true; 252 size = iattr->ia_size; 253 } 254 255 for (i = 0; i < nr_maps; i++) { 256 u64 start, length, end; 257 258 start = maps[i].offset; 259 if (start > size) 260 continue; 261 262 end = start + maps[i].length; 263 if (end > size) 264 end = size; 265 266 length = end - start; 267 if (!length) 268 continue; 269 270 /* 271 * Make sure reads through the pagecache see the new data. 272 */ 273 error = invalidate_inode_pages2_range(inode->i_mapping, 274 start >> PAGE_SHIFT, 275 (end - 1) >> PAGE_SHIFT); 276 WARN_ON_ONCE(error); 277 278 error = xfs_iomap_write_unwritten(ip, start, length, false); 279 if (error) 280 goto out_drop_iolock; 281 } 282 283 if (update_isize) { 284 error = xfs_pnfs_validate_isize(ip, size); 285 if (error) 286 goto out_drop_iolock; 287 } 288 289 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); 290 if (error) 291 goto out_drop_iolock; 292 293 xfs_ilock(ip, XFS_ILOCK_EXCL); 294 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 295 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 296 297 xfs_setattr_time(ip, iattr); 298 if (update_isize) { 299 i_size_write(inode, iattr->ia_size); 300 ip->i_d.di_size = iattr->ia_size; 301 } 302 303 xfs_trans_set_sync(tp); 304 error = xfs_trans_commit(tp); 305 306 out_drop_iolock: 307 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 308 return error; 309 } 310