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