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