1
2
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
24
25
26
27
28
29
30
31
32int
33xfs_break_layouts(
34 struct inode *inode,
35 uint *iolock)
36{
37 struct xfs_inode *ip = XFS_I(inode);
38 int error;
39
40 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL));
41
42 while ((error = break_layout(inode, false) == -EWOULDBLOCK)) {
43 xfs_iunlock(ip, *iolock);
44 error = break_layout(inode, true);
45 *iolock = XFS_IOLOCK_EXCL;
46 xfs_ilock(ip, *iolock);
47 }
48
49 return error;
50}
51
52
53
54
55
56int
57xfs_fs_get_uuid(
58 struct super_block *sb,
59 u8 *buf,
60 u32 *len,
61 u64 *offset)
62{
63 struct xfs_mount *mp = XFS_M(sb);
64
65 printk_once(KERN_NOTICE
66"XFS (%s): using experimental pNFS feature, use at your own risk!\n",
67 mp->m_fsname);
68
69 if (*len < sizeof(uuid_t))
70 return -EINVAL;
71
72 memcpy(buf, &mp->m_sb.sb_uuid, sizeof(uuid_t));
73 *len = sizeof(uuid_t);
74 *offset = offsetof(struct xfs_dsb, sb_uuid);
75 return 0;
76}
77
78
79
80
81int
82xfs_fs_map_blocks(
83 struct inode *inode,
84 loff_t offset,
85 u64 length,
86 struct iomap *iomap,
87 bool write,
88 u32 *device_generation)
89{
90 struct xfs_inode *ip = XFS_I(inode);
91 struct xfs_mount *mp = ip->i_mount;
92 struct xfs_bmbt_irec imap;
93 xfs_fileoff_t offset_fsb, end_fsb;
94 loff_t limit;
95 int bmapi_flags = XFS_BMAPI_ENTIRE;
96 int nimaps = 1;
97 uint lock_flags;
98 int error = 0;
99
100 if (XFS_FORCED_SHUTDOWN(mp))
101 return -EIO;
102
103
104
105
106
107
108 if (XFS_IS_REALTIME_INODE(ip))
109 return -ENXIO;
110
111
112
113
114
115 if (xfs_is_reflink_inode(ip))
116 return -ENXIO;
117
118
119
120
121
122
123
124
125 xfs_ilock(ip, XFS_IOLOCK_EXCL);
126
127 error = -EINVAL;
128 limit = mp->m_super->s_maxbytes;
129 if (!write)
130 limit = max(limit, round_up(i_size_read(inode),
131 inode->i_sb->s_blocksize));
132 if (offset > limit)
133 goto out_unlock;
134 if (offset > limit - length)
135 length = limit - offset;
136
137 error = filemap_write_and_wait(inode->i_mapping);
138 if (error)
139 goto out_unlock;
140 error = invalidate_inode_pages2(inode->i_mapping);
141 if (WARN_ON_ONCE(error))
142 return error;
143
144 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + length);
145 offset_fsb = XFS_B_TO_FSBT(mp, offset);
146
147 lock_flags = xfs_ilock_data_map_shared(ip);
148 error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
149 &imap, &nimaps, bmapi_flags);
150 xfs_iunlock(ip, lock_flags);
151
152 if (error)
153 goto out_unlock;
154
155 if (write) {
156 enum xfs_prealloc_flags flags = 0;
157
158 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
159
160 if (!nimaps || imap.br_startblock == HOLESTARTBLOCK) {
161
162
163
164
165 xfs_ilock(ip, XFS_ILOCK_SHARED);
166 error = xfs_iomap_write_direct(ip, offset, length,
167 &imap, nimaps);
168 if (error)
169 goto out_unlock;
170
171
172
173
174
175
176
177 flags |= XFS_PREALLOC_SET | XFS_PREALLOC_SYNC;
178 }
179
180 error = xfs_update_prealloc_flags(ip, flags);
181 if (error)
182 goto out_unlock;
183 }
184 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
185
186 xfs_bmbt_to_iomap(ip, iomap, &imap);
187 *device_generation = mp->m_generation;
188 return error;
189out_unlock:
190 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
191 return error;
192}
193
194
195
196
197static int
198xfs_pnfs_validate_isize(
199 struct xfs_inode *ip,
200 xfs_off_t isize)
201{
202 struct xfs_bmbt_irec imap;
203 int nimaps = 1;
204 int error = 0;
205
206 xfs_ilock(ip, XFS_ILOCK_SHARED);
207 error = xfs_bmapi_read(ip, XFS_B_TO_FSBT(ip->i_mount, isize - 1), 1,
208 &imap, &nimaps, 0);
209 xfs_iunlock(ip, XFS_ILOCK_SHARED);
210 if (error)
211 return error;
212
213 if (imap.br_startblock == HOLESTARTBLOCK ||
214 imap.br_startblock == DELAYSTARTBLOCK ||
215 imap.br_state == XFS_EXT_UNWRITTEN)
216 return -EIO;
217 return 0;
218}
219
220
221
222
223
224
225
226
227
228
229
230int
231xfs_fs_commit_blocks(
232 struct inode *inode,
233 struct iomap *maps,
234 int nr_maps,
235 struct iattr *iattr)
236{
237 struct xfs_inode *ip = XFS_I(inode);
238 struct xfs_mount *mp = ip->i_mount;
239 struct xfs_trans *tp;
240 bool update_isize = false;
241 int error, i;
242 loff_t size;
243
244 ASSERT(iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME));
245
246 xfs_ilock(ip, XFS_IOLOCK_EXCL);
247
248 size = i_size_read(inode);
249 if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size > size) {
250 update_isize = true;
251 size = iattr->ia_size;
252 }
253
254 for (i = 0; i < nr_maps; i++) {
255 u64 start, length, end;
256
257 start = maps[i].offset;
258 if (start > size)
259 continue;
260
261 end = start + maps[i].length;
262 if (end > size)
263 end = size;
264
265 length = end - start;
266 if (!length)
267 continue;
268
269
270
271
272 error = invalidate_inode_pages2_range(inode->i_mapping,
273 start >> PAGE_SHIFT,
274 (end - 1) >> PAGE_SHIFT);
275 WARN_ON_ONCE(error);
276
277 error = xfs_iomap_write_unwritten(ip, start, length);
278 if (error)
279 goto out_drop_iolock;
280 }
281
282 if (update_isize) {
283 error = xfs_pnfs_validate_isize(ip, size);
284 if (error)
285 goto out_drop_iolock;
286 }
287
288 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
289 if (error)
290 goto out_drop_iolock;
291
292 xfs_ilock(ip, XFS_ILOCK_EXCL);
293 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
294 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
295
296 xfs_setattr_time(ip, iattr);
297 if (update_isize) {
298 i_size_write(inode, iattr->ia_size);
299 ip->i_d.di_size = iattr->ia_size;
300 }
301
302 xfs_trans_set_sync(tp);
303 error = xfs_trans_commit(tp);
304
305out_drop_iolock:
306 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
307 return error;
308}
309