1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. |
4 | * Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved. |
5 | */ |
6 | |
7 | #include <linux/slab.h> |
8 | #include <linux/spinlock.h> |
9 | #include <linux/completion.h> |
10 | #include <linux/buffer_head.h> |
11 | #include <linux/namei.h> |
12 | #include <linux/mm.h> |
13 | #include <linux/cred.h> |
14 | #include <linux/xattr.h> |
15 | #include <linux/posix_acl.h> |
16 | #include <linux/gfs2_ondisk.h> |
17 | #include <linux/crc32.h> |
18 | #include <linux/iomap.h> |
19 | #include <linux/security.h> |
20 | #include <linux/fiemap.h> |
21 | #include <linux/uaccess.h> |
22 | |
23 | #include "gfs2.h" |
24 | #include "incore.h" |
25 | #include "acl.h" |
26 | #include "bmap.h" |
27 | #include "dir.h" |
28 | #include "xattr.h" |
29 | #include "glock.h" |
30 | #include "inode.h" |
31 | #include "meta_io.h" |
32 | #include "quota.h" |
33 | #include "rgrp.h" |
34 | #include "trans.h" |
35 | #include "util.h" |
36 | #include "super.h" |
37 | #include "glops.h" |
38 | |
39 | static const struct inode_operations gfs2_file_iops; |
40 | static const struct inode_operations gfs2_dir_iops; |
41 | static const struct inode_operations gfs2_symlink_iops; |
42 | |
43 | /** |
44 | * gfs2_set_iop - Sets inode operations |
45 | * @inode: The inode with correct i_mode filled in |
46 | * |
47 | * GFS2 lookup code fills in vfs inode contents based on info obtained |
48 | * from directory entry inside gfs2_inode_lookup(). |
49 | */ |
50 | |
51 | static void gfs2_set_iop(struct inode *inode) |
52 | { |
53 | struct gfs2_sbd *sdp = GFS2_SB(inode); |
54 | umode_t mode = inode->i_mode; |
55 | |
56 | if (S_ISREG(mode)) { |
57 | inode->i_op = &gfs2_file_iops; |
58 | if (gfs2_localflocks(sdp)) |
59 | inode->i_fop = &gfs2_file_fops_nolock; |
60 | else |
61 | inode->i_fop = &gfs2_file_fops; |
62 | } else if (S_ISDIR(mode)) { |
63 | inode->i_op = &gfs2_dir_iops; |
64 | if (gfs2_localflocks(sdp)) |
65 | inode->i_fop = &gfs2_dir_fops_nolock; |
66 | else |
67 | inode->i_fop = &gfs2_dir_fops; |
68 | } else if (S_ISLNK(mode)) { |
69 | inode->i_op = &gfs2_symlink_iops; |
70 | } else { |
71 | inode->i_op = &gfs2_file_iops; |
72 | init_special_inode(inode, inode->i_mode, inode->i_rdev); |
73 | } |
74 | } |
75 | |
76 | static int iget_test(struct inode *inode, void *opaque) |
77 | { |
78 | u64 no_addr = *(u64 *)opaque; |
79 | |
80 | return GFS2_I(inode)->i_no_addr == no_addr; |
81 | } |
82 | |
83 | static int iget_set(struct inode *inode, void *opaque) |
84 | { |
85 | u64 no_addr = *(u64 *)opaque; |
86 | |
87 | GFS2_I(inode)->i_no_addr = no_addr; |
88 | inode->i_ino = no_addr; |
89 | return 0; |
90 | } |
91 | |
92 | /** |
93 | * gfs2_inode_lookup - Lookup an inode |
94 | * @sb: The super block |
95 | * @type: The type of the inode |
96 | * @no_addr: The inode number |
97 | * @no_formal_ino: The inode generation number |
98 | * @blktype: Requested block type (GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED; |
99 | * GFS2_BLKST_FREE to indicate not to verify) |
100 | * |
101 | * If @type is DT_UNKNOWN, the inode type is fetched from disk. |
102 | * |
103 | * If @blktype is anything other than GFS2_BLKST_FREE (which is used as a |
104 | * placeholder because it doesn't otherwise make sense), the on-disk block type |
105 | * is verified to be @blktype. |
106 | * |
107 | * When @no_formal_ino is non-zero, this function will return ERR_PTR(-ESTALE) |
108 | * if it detects that @no_formal_ino doesn't match the actual inode generation |
109 | * number. However, it doesn't always know unless @type is DT_UNKNOWN. |
110 | * |
111 | * Returns: A VFS inode, or an error |
112 | */ |
113 | |
114 | struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type, |
115 | u64 no_addr, u64 no_formal_ino, |
116 | unsigned int blktype) |
117 | { |
118 | struct inode *inode; |
119 | struct gfs2_inode *ip; |
120 | struct gfs2_holder i_gh; |
121 | int error; |
122 | |
123 | gfs2_holder_mark_uninitialized(gh: &i_gh); |
124 | inode = iget5_locked(sb, no_addr, test: iget_test, set: iget_set, &no_addr); |
125 | if (!inode) |
126 | return ERR_PTR(error: -ENOMEM); |
127 | |
128 | ip = GFS2_I(inode); |
129 | |
130 | if (inode->i_state & I_NEW) { |
131 | struct gfs2_sbd *sdp = GFS2_SB(inode); |
132 | struct gfs2_glock *io_gl; |
133 | int = 0; |
134 | |
135 | error = gfs2_glock_get(sdp, number: no_addr, glops: &gfs2_inode_glops, create: CREATE, |
136 | glp: &ip->i_gl); |
137 | if (unlikely(error)) |
138 | goto fail; |
139 | |
140 | error = gfs2_glock_get(sdp, number: no_addr, glops: &gfs2_iopen_glops, create: CREATE, |
141 | glp: &io_gl); |
142 | if (unlikely(error)) |
143 | goto fail; |
144 | |
145 | /* |
146 | * The only caller that sets @blktype to GFS2_BLKST_UNLINKED is |
147 | * delete_work_func(). Make sure not to cancel the delete work |
148 | * from within itself here. |
149 | */ |
150 | if (blktype == GFS2_BLKST_UNLINKED) |
151 | extra_flags |= LM_FLAG_TRY; |
152 | else |
153 | gfs2_cancel_delete_work(gl: io_gl); |
154 | error = gfs2_glock_nq_init(gl: io_gl, LM_ST_SHARED, |
155 | GL_EXACT | GL_NOPID | extra_flags, |
156 | gh: &ip->i_iopen_gh); |
157 | gfs2_glock_put(gl: io_gl); |
158 | if (unlikely(error)) |
159 | goto fail; |
160 | |
161 | if (type == DT_UNKNOWN || blktype != GFS2_BLKST_FREE) { |
162 | /* |
163 | * The GL_SKIP flag indicates to skip reading the inode |
164 | * block. We read the inode when instantiating it |
165 | * after possibly checking the block type. |
166 | */ |
167 | error = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_EXCLUSIVE, |
168 | GL_SKIP, gh: &i_gh); |
169 | if (error) |
170 | goto fail; |
171 | |
172 | error = -ESTALE; |
173 | if (no_formal_ino && |
174 | gfs2_inode_already_deleted(gl: ip->i_gl, generation: no_formal_ino)) |
175 | goto fail; |
176 | |
177 | if (blktype != GFS2_BLKST_FREE) { |
178 | error = gfs2_check_blk_type(sdp, no_addr, |
179 | type: blktype); |
180 | if (error) |
181 | goto fail; |
182 | } |
183 | } |
184 | |
185 | set_bit(nr: GLF_INSTANTIATE_NEEDED, addr: &ip->i_gl->gl_flags); |
186 | |
187 | /* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */ |
188 | inode_set_atime(inode, |
189 | sec: 1LL << (8 * sizeof(inode_get_atime_sec(inode)) - 1), |
190 | nsec: 0); |
191 | |
192 | glock_set_object(gl: ip->i_gl, object: ip); |
193 | |
194 | if (type == DT_UNKNOWN) { |
195 | /* Inode glock must be locked already */ |
196 | error = gfs2_instantiate(gh: &i_gh); |
197 | if (error) { |
198 | glock_clear_object(gl: ip->i_gl, object: ip); |
199 | goto fail; |
200 | } |
201 | } else { |
202 | ip->i_no_formal_ino = no_formal_ino; |
203 | inode->i_mode = DT2IF(type); |
204 | } |
205 | |
206 | if (gfs2_holder_initialized(gh: &i_gh)) |
207 | gfs2_glock_dq_uninit(gh: &i_gh); |
208 | glock_set_object(gl: ip->i_iopen_gh.gh_gl, object: ip); |
209 | |
210 | gfs2_set_iop(inode); |
211 | unlock_new_inode(inode); |
212 | } |
213 | |
214 | if (no_formal_ino && ip->i_no_formal_ino && |
215 | no_formal_ino != ip->i_no_formal_ino) { |
216 | iput(inode); |
217 | return ERR_PTR(error: -ESTALE); |
218 | } |
219 | |
220 | return inode; |
221 | |
222 | fail: |
223 | if (error == GLR_TRYFAILED) |
224 | error = -EAGAIN; |
225 | if (gfs2_holder_initialized(gh: &ip->i_iopen_gh)) |
226 | gfs2_glock_dq_uninit(gh: &ip->i_iopen_gh); |
227 | if (gfs2_holder_initialized(gh: &i_gh)) |
228 | gfs2_glock_dq_uninit(gh: &i_gh); |
229 | if (ip->i_gl) { |
230 | gfs2_glock_put(gl: ip->i_gl); |
231 | ip->i_gl = NULL; |
232 | } |
233 | iget_failed(inode); |
234 | return ERR_PTR(error); |
235 | } |
236 | |
237 | /** |
238 | * gfs2_lookup_by_inum - look up an inode by inode number |
239 | * @sdp: The super block |
240 | * @no_addr: The inode number |
241 | * @no_formal_ino: The inode generation number (0 for any) |
242 | * @blktype: Requested block type (see gfs2_inode_lookup) |
243 | */ |
244 | struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr, |
245 | u64 no_formal_ino, unsigned int blktype) |
246 | { |
247 | struct super_block *sb = sdp->sd_vfs; |
248 | struct inode *inode; |
249 | int error; |
250 | |
251 | inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, no_formal_ino, |
252 | blktype); |
253 | if (IS_ERR(ptr: inode)) |
254 | return inode; |
255 | |
256 | if (no_formal_ino) { |
257 | error = -EIO; |
258 | if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM) |
259 | goto fail_iput; |
260 | } |
261 | return inode; |
262 | |
263 | fail_iput: |
264 | iput(inode); |
265 | return ERR_PTR(error); |
266 | } |
267 | |
268 | |
269 | /** |
270 | * gfs2_lookup_meta - Look up an inode in a metadata directory |
271 | * @dip: The directory |
272 | * @name: The name of the inode |
273 | */ |
274 | struct inode *gfs2_lookup_meta(struct inode *dip, const char *name) |
275 | { |
276 | struct qstr qstr; |
277 | struct inode *inode; |
278 | |
279 | gfs2_str2qstr(name: &qstr, fname: name); |
280 | inode = gfs2_lookupi(dir: dip, name: &qstr, is_root: 1); |
281 | if (IS_ERR_OR_NULL(ptr: inode)) |
282 | return inode ? inode : ERR_PTR(error: -ENOENT); |
283 | |
284 | /* |
285 | * Must not call back into the filesystem when allocating |
286 | * pages in the metadata inode's address space. |
287 | */ |
288 | mapping_set_gfp_mask(m: inode->i_mapping, GFP_NOFS); |
289 | |
290 | return inode; |
291 | } |
292 | |
293 | |
294 | /** |
295 | * gfs2_lookupi - Look up a filename in a directory and return its inode |
296 | * @dir: The inode of the directory containing the inode to look-up |
297 | * @name: The name of the inode to look for |
298 | * @is_root: If 1, ignore the caller's permissions |
299 | * |
300 | * This can be called via the VFS filldir function when NFS is doing |
301 | * a readdirplus and the inode which its intending to stat isn't |
302 | * already in cache. In this case we must not take the directory glock |
303 | * again, since the readdir call will have already taken that lock. |
304 | * |
305 | * Returns: errno |
306 | */ |
307 | |
308 | struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name, |
309 | int is_root) |
310 | { |
311 | struct super_block *sb = dir->i_sb; |
312 | struct gfs2_inode *dip = GFS2_I(inode: dir); |
313 | struct gfs2_holder d_gh; |
314 | int error = 0; |
315 | struct inode *inode = NULL; |
316 | |
317 | gfs2_holder_mark_uninitialized(gh: &d_gh); |
318 | if (!name->len || name->len > GFS2_FNAMESIZE) |
319 | return ERR_PTR(error: -ENAMETOOLONG); |
320 | |
321 | if ((name->len == 1 && memcmp(p: name->name, q: "." , size: 1) == 0) || |
322 | (name->len == 2 && memcmp(p: name->name, q: ".." , size: 2) == 0 && |
323 | dir == d_inode(dentry: sb->s_root))) { |
324 | igrab(dir); |
325 | return dir; |
326 | } |
327 | |
328 | if (gfs2_glock_is_locked_by_me(gl: dip->i_gl) == NULL) { |
329 | error = gfs2_glock_nq_init(gl: dip->i_gl, LM_ST_SHARED, flags: 0, gh: &d_gh); |
330 | if (error) |
331 | return ERR_PTR(error); |
332 | } |
333 | |
334 | if (!is_root) { |
335 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: dir, MAY_EXEC); |
336 | if (error) |
337 | goto out; |
338 | } |
339 | |
340 | inode = gfs2_dir_search(dir, filename: name, fail_on_exist: false); |
341 | if (IS_ERR(ptr: inode)) |
342 | error = PTR_ERR(ptr: inode); |
343 | out: |
344 | if (gfs2_holder_initialized(gh: &d_gh)) |
345 | gfs2_glock_dq_uninit(gh: &d_gh); |
346 | if (error == -ENOENT) |
347 | return NULL; |
348 | return inode ? inode : ERR_PTR(error); |
349 | } |
350 | |
351 | /** |
352 | * create_ok - OK to create a new on-disk inode here? |
353 | * @dip: Directory in which dinode is to be created |
354 | * @name: Name of new dinode |
355 | * @mode: |
356 | * |
357 | * Returns: errno |
358 | */ |
359 | |
360 | static int create_ok(struct gfs2_inode *dip, const struct qstr *name, |
361 | umode_t mode) |
362 | { |
363 | int error; |
364 | |
365 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: &dip->i_inode, |
366 | MAY_WRITE | MAY_EXEC); |
367 | if (error) |
368 | return error; |
369 | |
370 | /* Don't create entries in an unlinked directory */ |
371 | if (!dip->i_inode.i_nlink) |
372 | return -ENOENT; |
373 | |
374 | if (dip->i_entries == (u32)-1) |
375 | return -EFBIG; |
376 | if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1) |
377 | return -EMLINK; |
378 | |
379 | return 0; |
380 | } |
381 | |
382 | static void munge_mode_uid_gid(const struct gfs2_inode *dip, |
383 | struct inode *inode) |
384 | { |
385 | if (GFS2_SB(inode: &dip->i_inode)->sd_args.ar_suiddir && |
386 | (dip->i_inode.i_mode & S_ISUID) && |
387 | !uid_eq(left: dip->i_inode.i_uid, GLOBAL_ROOT_UID)) { |
388 | if (S_ISDIR(inode->i_mode)) |
389 | inode->i_mode |= S_ISUID; |
390 | else if (!uid_eq(dip->i_inode.i_uid, current_fsuid())) |
391 | inode->i_mode &= ~07111; |
392 | inode->i_uid = dip->i_inode.i_uid; |
393 | } else |
394 | inode->i_uid = current_fsuid(); |
395 | |
396 | if (dip->i_inode.i_mode & S_ISGID) { |
397 | if (S_ISDIR(inode->i_mode)) |
398 | inode->i_mode |= S_ISGID; |
399 | inode->i_gid = dip->i_inode.i_gid; |
400 | } else |
401 | inode->i_gid = current_fsgid(); |
402 | } |
403 | |
404 | static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks) |
405 | { |
406 | struct gfs2_sbd *sdp = GFS2_SB(inode: &ip->i_inode); |
407 | struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, }; |
408 | int error; |
409 | |
410 | error = gfs2_quota_lock_check(ip, ap: &ap); |
411 | if (error) |
412 | goto out; |
413 | |
414 | error = gfs2_inplace_reserve(ip, ap: &ap); |
415 | if (error) |
416 | goto out_quota; |
417 | |
418 | error = gfs2_trans_begin(sdp, blocks: (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, revokes: 0); |
419 | if (error) |
420 | goto out_ipreserv; |
421 | |
422 | error = gfs2_alloc_blocks(ip, bn: &ip->i_no_addr, n: dblocks, dinode: 1); |
423 | if (error) |
424 | goto out_trans_end; |
425 | |
426 | ip->i_no_formal_ino = ip->i_generation; |
427 | ip->i_inode.i_ino = ip->i_no_addr; |
428 | ip->i_goal = ip->i_no_addr; |
429 | if (*dblocks > 1) |
430 | ip->i_eattr = ip->i_no_addr + 1; |
431 | |
432 | out_trans_end: |
433 | gfs2_trans_end(sdp); |
434 | out_ipreserv: |
435 | gfs2_inplace_release(ip); |
436 | out_quota: |
437 | gfs2_quota_unlock(ip); |
438 | out: |
439 | return error; |
440 | } |
441 | |
442 | static void gfs2_init_dir(struct buffer_head *dibh, |
443 | const struct gfs2_inode *parent) |
444 | { |
445 | struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data; |
446 | struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1); |
447 | |
448 | gfs2_qstr2dirent(name: &gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent); |
449 | dent->de_inum = di->di_num; /* already GFS2 endian */ |
450 | dent->de_type = cpu_to_be16(DT_DIR); |
451 | |
452 | dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1)); |
453 | gfs2_qstr2dirent(name: &gfs2_qdotdot, reclen: dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent); |
454 | gfs2_inum_out(ip: parent, dent); |
455 | dent->de_type = cpu_to_be16(DT_DIR); |
456 | |
457 | } |
458 | |
459 | /** |
460 | * gfs2_init_xattr - Initialise an xattr block for a new inode |
461 | * @ip: The inode in question |
462 | * |
463 | * This sets up an empty xattr block for a new inode, ready to |
464 | * take any ACLs, LSM xattrs, etc. |
465 | */ |
466 | |
467 | static void gfs2_init_xattr(struct gfs2_inode *ip) |
468 | { |
469 | struct gfs2_sbd *sdp = GFS2_SB(inode: &ip->i_inode); |
470 | struct buffer_head *bh; |
471 | struct gfs2_ea_header *ea; |
472 | |
473 | bh = gfs2_meta_new(gl: ip->i_gl, blkno: ip->i_eattr); |
474 | gfs2_trans_add_meta(gl: ip->i_gl, bh); |
475 | gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA); |
476 | gfs2_buffer_clear_tail(bh, head: sizeof(struct gfs2_meta_header)); |
477 | |
478 | ea = GFS2_EA_BH2FIRST(bh); |
479 | ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize); |
480 | ea->ea_type = GFS2_EATYPE_UNUSED; |
481 | ea->ea_flags = GFS2_EAFLAG_LAST; |
482 | |
483 | brelse(bh); |
484 | } |
485 | |
486 | /** |
487 | * init_dinode - Fill in a new dinode structure |
488 | * @dip: The directory this inode is being created in |
489 | * @ip: The inode |
490 | * @symname: The symlink destination (if a symlink) |
491 | * |
492 | */ |
493 | |
494 | static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip, |
495 | const char *symname) |
496 | { |
497 | struct gfs2_dinode *di; |
498 | struct buffer_head *dibh; |
499 | |
500 | dibh = gfs2_meta_new(gl: ip->i_gl, blkno: ip->i_no_addr); |
501 | gfs2_trans_add_meta(gl: ip->i_gl, bh: dibh); |
502 | di = (struct gfs2_dinode *)dibh->b_data; |
503 | gfs2_dinode_out(ip, buf: di); |
504 | |
505 | di->di_major = cpu_to_be32(imajor(&ip->i_inode)); |
506 | di->di_minor = cpu_to_be32(iminor(&ip->i_inode)); |
507 | di->__pad1 = 0; |
508 | di->__pad2 = 0; |
509 | di->__pad3 = 0; |
510 | memset(&di->__pad4, 0, sizeof(di->__pad4)); |
511 | memset(&di->di_reserved, 0, sizeof(di->di_reserved)); |
512 | gfs2_buffer_clear_tail(bh: dibh, head: sizeof(struct gfs2_dinode)); |
513 | |
514 | switch(ip->i_inode.i_mode & S_IFMT) { |
515 | case S_IFDIR: |
516 | gfs2_init_dir(dibh, parent: dip); |
517 | break; |
518 | case S_IFLNK: |
519 | memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size); |
520 | break; |
521 | } |
522 | |
523 | set_buffer_uptodate(dibh); |
524 | brelse(bh: dibh); |
525 | } |
526 | |
527 | /** |
528 | * gfs2_trans_da_blks - Calculate number of blocks to link inode |
529 | * @dip: The directory we are linking into |
530 | * @da: The dir add information |
531 | * @nr_inodes: The number of inodes involved |
532 | * |
533 | * This calculate the number of blocks we need to reserve in a |
534 | * transaction to link @nr_inodes into a directory. In most cases |
535 | * @nr_inodes will be 2 (the directory plus the inode being linked in) |
536 | * but in case of rename, 4 may be required. |
537 | * |
538 | * Returns: Number of blocks |
539 | */ |
540 | |
541 | static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip, |
542 | const struct gfs2_diradd *da, |
543 | unsigned nr_inodes) |
544 | { |
545 | return da->nr_blocks + gfs2_rg_blocks(ip: dip, requested: da->nr_blocks) + |
546 | (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS; |
547 | } |
548 | |
549 | static int link_dinode(struct gfs2_inode *dip, const struct qstr *name, |
550 | struct gfs2_inode *ip, struct gfs2_diradd *da) |
551 | { |
552 | struct gfs2_sbd *sdp = GFS2_SB(inode: &dip->i_inode); |
553 | struct gfs2_alloc_parms ap = { .target = da->nr_blocks, }; |
554 | int error; |
555 | |
556 | if (da->nr_blocks) { |
557 | error = gfs2_quota_lock_check(ip: dip, ap: &ap); |
558 | if (error) |
559 | goto fail_quota_locks; |
560 | |
561 | error = gfs2_inplace_reserve(ip: dip, ap: &ap); |
562 | if (error) |
563 | goto fail_quota_locks; |
564 | |
565 | error = gfs2_trans_begin(sdp, blocks: gfs2_trans_da_blks(dip, da, nr_inodes: 2), revokes: 0); |
566 | if (error) |
567 | goto fail_ipreserv; |
568 | } else { |
569 | error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, revokes: 0); |
570 | if (error) |
571 | goto fail_quota_locks; |
572 | } |
573 | |
574 | error = gfs2_dir_add(inode: &dip->i_inode, filename: name, ip, da); |
575 | |
576 | gfs2_trans_end(sdp); |
577 | fail_ipreserv: |
578 | gfs2_inplace_release(ip: dip); |
579 | fail_quota_locks: |
580 | gfs2_quota_unlock(ip: dip); |
581 | return error; |
582 | } |
583 | |
584 | static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array, |
585 | void *fs_info) |
586 | { |
587 | const struct xattr *xattr; |
588 | int err = 0; |
589 | |
590 | for (xattr = xattr_array; xattr->name != NULL; xattr++) { |
591 | err = __gfs2_xattr_set(inode, name: xattr->name, value: xattr->value, |
592 | size: xattr->value_len, flags: 0, |
593 | GFS2_EATYPE_SECURITY); |
594 | if (err < 0) |
595 | break; |
596 | } |
597 | return err; |
598 | } |
599 | |
600 | /** |
601 | * gfs2_create_inode - Create a new inode |
602 | * @dir: The parent directory |
603 | * @dentry: The new dentry |
604 | * @file: If non-NULL, the file which is being opened |
605 | * @mode: The permissions on the new inode |
606 | * @dev: For device nodes, this is the device number |
607 | * @symname: For symlinks, this is the link destination |
608 | * @size: The initial size of the inode (ignored for directories) |
609 | * @excl: Force fail if inode exists |
610 | * |
611 | * FIXME: Change to allocate the disk blocks and write them out in the same |
612 | * transaction. That way, we can no longer end up in a situation in which an |
613 | * inode is allocated, the node crashes, and the block looks like a valid |
614 | * inode. (With atomic creates in place, we will also no longer need to zero |
615 | * the link count and dirty the inode here on failure.) |
616 | * |
617 | * Returns: 0 on success, or error code |
618 | */ |
619 | |
620 | static int gfs2_create_inode(struct inode *dir, struct dentry *dentry, |
621 | struct file *file, |
622 | umode_t mode, dev_t dev, const char *symname, |
623 | unsigned int size, int excl) |
624 | { |
625 | const struct qstr *name = &dentry->d_name; |
626 | struct posix_acl *default_acl, *acl; |
627 | struct gfs2_holder d_gh, gh; |
628 | struct inode *inode = NULL; |
629 | struct gfs2_inode *dip = GFS2_I(inode: dir), *ip; |
630 | struct gfs2_sbd *sdp = GFS2_SB(inode: &dip->i_inode); |
631 | struct gfs2_glock *io_gl; |
632 | int error; |
633 | u32 aflags = 0; |
634 | unsigned blocks = 1; |
635 | struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, }; |
636 | |
637 | if (!name->len || name->len > GFS2_FNAMESIZE) |
638 | return -ENAMETOOLONG; |
639 | |
640 | error = gfs2_qa_get(ip: dip); |
641 | if (error) |
642 | return error; |
643 | |
644 | error = gfs2_rindex_update(sdp); |
645 | if (error) |
646 | goto fail; |
647 | |
648 | error = gfs2_glock_nq_init(gl: dip->i_gl, LM_ST_EXCLUSIVE, flags: 0, gh: &d_gh); |
649 | if (error) |
650 | goto fail; |
651 | gfs2_holder_mark_uninitialized(gh: &gh); |
652 | |
653 | error = create_ok(dip, name, mode); |
654 | if (error) |
655 | goto fail_gunlock; |
656 | |
657 | inode = gfs2_dir_search(dir, filename: &dentry->d_name, fail_on_exist: !S_ISREG(mode) || excl); |
658 | error = PTR_ERR(ptr: inode); |
659 | if (!IS_ERR(ptr: inode)) { |
660 | if (S_ISDIR(inode->i_mode)) { |
661 | iput(inode); |
662 | inode = ERR_PTR(error: -EISDIR); |
663 | goto fail_gunlock; |
664 | } |
665 | d_instantiate(dentry, inode); |
666 | error = 0; |
667 | if (file) { |
668 | if (S_ISREG(inode->i_mode)) |
669 | error = finish_open(file, dentry, open: gfs2_open_common); |
670 | else |
671 | error = finish_no_open(file, NULL); |
672 | } |
673 | gfs2_glock_dq_uninit(gh: &d_gh); |
674 | goto fail; |
675 | } else if (error != -ENOENT) { |
676 | goto fail_gunlock; |
677 | } |
678 | |
679 | error = gfs2_diradd_alloc_required(dir, filename: name, da: &da); |
680 | if (error < 0) |
681 | goto fail_gunlock; |
682 | |
683 | inode = new_inode(sb: sdp->sd_vfs); |
684 | error = -ENOMEM; |
685 | if (!inode) |
686 | goto fail_gunlock; |
687 | ip = GFS2_I(inode); |
688 | |
689 | error = posix_acl_create(dir, &mode, &default_acl, &acl); |
690 | if (error) |
691 | goto fail_gunlock; |
692 | |
693 | error = gfs2_qa_get(ip); |
694 | if (error) |
695 | goto fail_free_acls; |
696 | |
697 | inode->i_mode = mode; |
698 | set_nlink(inode, S_ISDIR(mode) ? 2 : 1); |
699 | inode->i_rdev = dev; |
700 | inode->i_size = size; |
701 | simple_inode_init_ts(inode); |
702 | munge_mode_uid_gid(dip, inode); |
703 | check_and_update_goal(ip: dip); |
704 | ip->i_goal = dip->i_goal; |
705 | ip->i_diskflags = 0; |
706 | ip->i_eattr = 0; |
707 | ip->i_height = 0; |
708 | ip->i_depth = 0; |
709 | ip->i_entries = 0; |
710 | ip->i_no_addr = 0; /* Temporarily zero until real addr is assigned */ |
711 | |
712 | switch(mode & S_IFMT) { |
713 | case S_IFREG: |
714 | if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) || |
715 | gfs2_tune_get(sdp, gt_new_files_jdata)) |
716 | ip->i_diskflags |= GFS2_DIF_JDATA; |
717 | gfs2_set_aops(inode); |
718 | break; |
719 | case S_IFDIR: |
720 | ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA); |
721 | ip->i_diskflags |= GFS2_DIF_JDATA; |
722 | ip->i_entries = 2; |
723 | break; |
724 | } |
725 | |
726 | /* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */ |
727 | if (dip->i_diskflags & GFS2_DIF_SYSTEM) |
728 | ip->i_diskflags |= GFS2_DIF_SYSTEM; |
729 | |
730 | gfs2_set_inode_flags(inode); |
731 | |
732 | if ((GFS2_I(inode: d_inode(dentry: sdp->sd_root_dir)) == dip) || |
733 | (dip->i_diskflags & GFS2_DIF_TOPDIR)) |
734 | aflags |= GFS2_AF_ORLOV; |
735 | |
736 | if (default_acl || acl) |
737 | blocks++; |
738 | |
739 | error = alloc_dinode(ip, flags: aflags, dblocks: &blocks); |
740 | if (error) |
741 | goto fail_free_inode; |
742 | |
743 | gfs2_set_inode_blocks(inode, blocks); |
744 | |
745 | error = gfs2_glock_get(sdp, number: ip->i_no_addr, glops: &gfs2_inode_glops, create: CREATE, glp: &ip->i_gl); |
746 | if (error) |
747 | goto fail_free_inode; |
748 | |
749 | error = gfs2_glock_get(sdp, number: ip->i_no_addr, glops: &gfs2_iopen_glops, create: CREATE, glp: &io_gl); |
750 | if (error) |
751 | goto fail_free_inode; |
752 | gfs2_cancel_delete_work(gl: io_gl); |
753 | |
754 | retry: |
755 | error = insert_inode_locked4(inode, ip->i_no_addr, test: iget_test, &ip->i_no_addr); |
756 | if (error == -EBUSY) |
757 | goto retry; |
758 | if (error) |
759 | goto fail_gunlock2; |
760 | |
761 | error = gfs2_glock_nq_init(gl: io_gl, LM_ST_SHARED, GL_EXACT | GL_NOPID, |
762 | gh: &ip->i_iopen_gh); |
763 | if (error) |
764 | goto fail_gunlock2; |
765 | |
766 | error = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, gh: &gh); |
767 | if (error) |
768 | goto fail_gunlock3; |
769 | |
770 | error = gfs2_trans_begin(sdp, blocks, revokes: 0); |
771 | if (error) |
772 | goto fail_gunlock3; |
773 | |
774 | if (blocks > 1) |
775 | gfs2_init_xattr(ip); |
776 | init_dinode(dip, ip, symname); |
777 | gfs2_trans_end(sdp); |
778 | |
779 | glock_set_object(gl: ip->i_gl, object: ip); |
780 | glock_set_object(gl: io_gl, object: ip); |
781 | gfs2_set_iop(inode); |
782 | |
783 | if (default_acl) { |
784 | error = __gfs2_set_acl(inode, acl: default_acl, ACL_TYPE_DEFAULT); |
785 | if (error) |
786 | goto fail_gunlock4; |
787 | posix_acl_release(acl: default_acl); |
788 | default_acl = NULL; |
789 | } |
790 | if (acl) { |
791 | error = __gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS); |
792 | if (error) |
793 | goto fail_gunlock4; |
794 | posix_acl_release(acl); |
795 | acl = NULL; |
796 | } |
797 | |
798 | error = security_inode_init_security(inode: &ip->i_inode, dir: &dip->i_inode, qstr: name, |
799 | initxattrs: &gfs2_initxattrs, NULL); |
800 | if (error) |
801 | goto fail_gunlock4; |
802 | |
803 | error = link_dinode(dip, name, ip, da: &da); |
804 | if (error) |
805 | goto fail_gunlock4; |
806 | |
807 | mark_inode_dirty(inode); |
808 | d_instantiate(dentry, inode); |
809 | /* After instantiate, errors should result in evict which will destroy |
810 | * both inode and iopen glocks properly. */ |
811 | if (file) { |
812 | file->f_mode |= FMODE_CREATED; |
813 | error = finish_open(file, dentry, open: gfs2_open_common); |
814 | } |
815 | gfs2_glock_dq_uninit(gh: &d_gh); |
816 | gfs2_qa_put(ip); |
817 | gfs2_glock_dq_uninit(gh: &gh); |
818 | gfs2_glock_put(gl: io_gl); |
819 | gfs2_qa_put(ip: dip); |
820 | unlock_new_inode(inode); |
821 | return error; |
822 | |
823 | fail_gunlock4: |
824 | glock_clear_object(gl: ip->i_gl, object: ip); |
825 | glock_clear_object(gl: io_gl, object: ip); |
826 | fail_gunlock3: |
827 | gfs2_glock_dq_uninit(gh: &ip->i_iopen_gh); |
828 | fail_gunlock2: |
829 | gfs2_glock_put(gl: io_gl); |
830 | fail_free_inode: |
831 | if (ip->i_gl) { |
832 | gfs2_glock_put(gl: ip->i_gl); |
833 | ip->i_gl = NULL; |
834 | } |
835 | gfs2_rs_deltree(rs: &ip->i_res); |
836 | gfs2_qa_put(ip); |
837 | fail_free_acls: |
838 | posix_acl_release(acl: default_acl); |
839 | posix_acl_release(acl); |
840 | fail_gunlock: |
841 | gfs2_dir_no_add(da: &da); |
842 | gfs2_glock_dq_uninit(gh: &d_gh); |
843 | if (!IS_ERR_OR_NULL(ptr: inode)) { |
844 | set_bit(nr: GIF_ALLOC_FAILED, addr: &ip->i_flags); |
845 | clear_nlink(inode); |
846 | if (ip->i_no_addr) |
847 | mark_inode_dirty(inode); |
848 | if (inode->i_state & I_NEW) |
849 | iget_failed(inode); |
850 | else |
851 | iput(inode); |
852 | } |
853 | if (gfs2_holder_initialized(gh: &gh)) |
854 | gfs2_glock_dq_uninit(gh: &gh); |
855 | fail: |
856 | gfs2_qa_put(ip: dip); |
857 | return error; |
858 | } |
859 | |
860 | /** |
861 | * gfs2_create - Create a file |
862 | * @idmap: idmap of the mount the inode was found from |
863 | * @dir: The directory in which to create the file |
864 | * @dentry: The dentry of the new file |
865 | * @mode: The mode of the new file |
866 | * @excl: Force fail if inode exists |
867 | * |
868 | * Returns: errno |
869 | */ |
870 | |
871 | static int gfs2_create(struct mnt_idmap *idmap, struct inode *dir, |
872 | struct dentry *dentry, umode_t mode, bool excl) |
873 | { |
874 | return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, dev: 0, NULL, size: 0, excl); |
875 | } |
876 | |
877 | /** |
878 | * __gfs2_lookup - Look up a filename in a directory and return its inode |
879 | * @dir: The directory inode |
880 | * @dentry: The dentry of the new inode |
881 | * @file: File to be opened |
882 | * |
883 | * |
884 | * Returns: errno |
885 | */ |
886 | |
887 | static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry, |
888 | struct file *file) |
889 | { |
890 | struct inode *inode; |
891 | struct dentry *d; |
892 | struct gfs2_holder gh; |
893 | struct gfs2_glock *gl; |
894 | int error; |
895 | |
896 | inode = gfs2_lookupi(dir, name: &dentry->d_name, is_root: 0); |
897 | if (inode == NULL) { |
898 | d_add(dentry, NULL); |
899 | return NULL; |
900 | } |
901 | if (IS_ERR(ptr: inode)) |
902 | return ERR_CAST(ptr: inode); |
903 | |
904 | gl = GFS2_I(inode)->i_gl; |
905 | error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, gh: &gh); |
906 | if (error) { |
907 | iput(inode); |
908 | return ERR_PTR(error); |
909 | } |
910 | |
911 | d = d_splice_alias(inode, dentry); |
912 | if (IS_ERR(ptr: d)) { |
913 | gfs2_glock_dq_uninit(gh: &gh); |
914 | return d; |
915 | } |
916 | if (file && S_ISREG(inode->i_mode)) |
917 | error = finish_open(file, dentry, open: gfs2_open_common); |
918 | |
919 | gfs2_glock_dq_uninit(gh: &gh); |
920 | if (error) { |
921 | dput(d); |
922 | return ERR_PTR(error); |
923 | } |
924 | return d; |
925 | } |
926 | |
927 | static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry, |
928 | unsigned flags) |
929 | { |
930 | return __gfs2_lookup(dir, dentry, NULL); |
931 | } |
932 | |
933 | /** |
934 | * gfs2_link - Link to a file |
935 | * @old_dentry: The inode to link |
936 | * @dir: Add link to this directory |
937 | * @dentry: The name of the link |
938 | * |
939 | * Link the inode in "old_dentry" into the directory "dir" with the |
940 | * name in "dentry". |
941 | * |
942 | * Returns: errno |
943 | */ |
944 | |
945 | static int gfs2_link(struct dentry *old_dentry, struct inode *dir, |
946 | struct dentry *dentry) |
947 | { |
948 | struct gfs2_inode *dip = GFS2_I(inode: dir); |
949 | struct gfs2_sbd *sdp = GFS2_SB(inode: dir); |
950 | struct inode *inode = d_inode(dentry: old_dentry); |
951 | struct gfs2_inode *ip = GFS2_I(inode); |
952 | struct gfs2_holder d_gh, gh; |
953 | struct buffer_head *dibh; |
954 | struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, }; |
955 | int error; |
956 | |
957 | if (S_ISDIR(inode->i_mode)) |
958 | return -EPERM; |
959 | |
960 | error = gfs2_qa_get(ip: dip); |
961 | if (error) |
962 | return error; |
963 | |
964 | gfs2_holder_init(gl: dip->i_gl, LM_ST_EXCLUSIVE, flags: 0, gh: &d_gh); |
965 | gfs2_holder_init(gl: ip->i_gl, LM_ST_EXCLUSIVE, flags: 0, gh: &gh); |
966 | |
967 | error = gfs2_glock_nq(gh: &d_gh); |
968 | if (error) |
969 | goto out_parent; |
970 | |
971 | error = gfs2_glock_nq(gh: &gh); |
972 | if (error) |
973 | goto out_child; |
974 | |
975 | error = -ENOENT; |
976 | if (inode->i_nlink == 0) |
977 | goto out_gunlock; |
978 | |
979 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: dir, MAY_WRITE | MAY_EXEC); |
980 | if (error) |
981 | goto out_gunlock; |
982 | |
983 | error = gfs2_dir_check(dir, filename: &dentry->d_name, NULL); |
984 | switch (error) { |
985 | case -ENOENT: |
986 | break; |
987 | case 0: |
988 | error = -EEXIST; |
989 | goto out_gunlock; |
990 | default: |
991 | goto out_gunlock; |
992 | } |
993 | |
994 | error = -EINVAL; |
995 | if (!dip->i_inode.i_nlink) |
996 | goto out_gunlock; |
997 | error = -EFBIG; |
998 | if (dip->i_entries == (u32)-1) |
999 | goto out_gunlock; |
1000 | error = -EPERM; |
1001 | if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) |
1002 | goto out_gunlock; |
1003 | error = -EMLINK; |
1004 | if (ip->i_inode.i_nlink == (u32)-1) |
1005 | goto out_gunlock; |
1006 | |
1007 | error = gfs2_diradd_alloc_required(dir, filename: &dentry->d_name, da: &da); |
1008 | if (error < 0) |
1009 | goto out_gunlock; |
1010 | |
1011 | if (da.nr_blocks) { |
1012 | struct gfs2_alloc_parms ap = { .target = da.nr_blocks, }; |
1013 | error = gfs2_quota_lock_check(ip: dip, ap: &ap); |
1014 | if (error) |
1015 | goto out_gunlock; |
1016 | |
1017 | error = gfs2_inplace_reserve(ip: dip, ap: &ap); |
1018 | if (error) |
1019 | goto out_gunlock_q; |
1020 | |
1021 | error = gfs2_trans_begin(sdp, blocks: gfs2_trans_da_blks(dip, da: &da, nr_inodes: 2), revokes: 0); |
1022 | if (error) |
1023 | goto out_ipres; |
1024 | } else { |
1025 | error = gfs2_trans_begin(sdp, blocks: 2 * RES_DINODE + RES_LEAF, revokes: 0); |
1026 | if (error) |
1027 | goto out_ipres; |
1028 | } |
1029 | |
1030 | error = gfs2_meta_inode_buffer(ip, bhp: &dibh); |
1031 | if (error) |
1032 | goto out_end_trans; |
1033 | |
1034 | error = gfs2_dir_add(inode: dir, filename: &dentry->d_name, ip, da: &da); |
1035 | if (error) |
1036 | goto out_brelse; |
1037 | |
1038 | gfs2_trans_add_meta(gl: ip->i_gl, bh: dibh); |
1039 | inc_nlink(inode: &ip->i_inode); |
1040 | inode_set_ctime_current(inode: &ip->i_inode); |
1041 | ihold(inode); |
1042 | d_instantiate(dentry, inode); |
1043 | mark_inode_dirty(inode); |
1044 | |
1045 | out_brelse: |
1046 | brelse(bh: dibh); |
1047 | out_end_trans: |
1048 | gfs2_trans_end(sdp); |
1049 | out_ipres: |
1050 | if (da.nr_blocks) |
1051 | gfs2_inplace_release(ip: dip); |
1052 | out_gunlock_q: |
1053 | if (da.nr_blocks) |
1054 | gfs2_quota_unlock(ip: dip); |
1055 | out_gunlock: |
1056 | gfs2_dir_no_add(da: &da); |
1057 | gfs2_glock_dq(gh: &gh); |
1058 | out_child: |
1059 | gfs2_glock_dq(gh: &d_gh); |
1060 | out_parent: |
1061 | gfs2_qa_put(ip: dip); |
1062 | gfs2_holder_uninit(gh: &d_gh); |
1063 | gfs2_holder_uninit(gh: &gh); |
1064 | return error; |
1065 | } |
1066 | |
1067 | /* |
1068 | * gfs2_unlink_ok - check to see that a inode is still in a directory |
1069 | * @dip: the directory |
1070 | * @name: the name of the file |
1071 | * @ip: the inode |
1072 | * |
1073 | * Assumes that the lock on (at least) @dip is held. |
1074 | * |
1075 | * Returns: 0 if the parent/child relationship is correct, errno if it isn't |
1076 | */ |
1077 | |
1078 | static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name, |
1079 | const struct gfs2_inode *ip) |
1080 | { |
1081 | int error; |
1082 | |
1083 | if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode)) |
1084 | return -EPERM; |
1085 | |
1086 | if ((dip->i_inode.i_mode & S_ISVTX) && |
1087 | !uid_eq(left: dip->i_inode.i_uid, current_fsuid()) && |
1088 | !uid_eq(left: ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER)) |
1089 | return -EPERM; |
1090 | |
1091 | if (IS_APPEND(&dip->i_inode)) |
1092 | return -EPERM; |
1093 | |
1094 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: &dip->i_inode, |
1095 | MAY_WRITE | MAY_EXEC); |
1096 | if (error) |
1097 | return error; |
1098 | |
1099 | return gfs2_dir_check(dir: &dip->i_inode, filename: name, ip); |
1100 | } |
1101 | |
1102 | /** |
1103 | * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it |
1104 | * @dip: The parent directory |
1105 | * @dentry: The dentry to unlink |
1106 | * |
1107 | * Called with all the locks and in a transaction. This will only be |
1108 | * called for a directory after it has been checked to ensure it is empty. |
1109 | * |
1110 | * Returns: 0 on success, or an error |
1111 | */ |
1112 | |
1113 | static int gfs2_unlink_inode(struct gfs2_inode *dip, |
1114 | const struct dentry *dentry) |
1115 | { |
1116 | struct inode *inode = d_inode(dentry); |
1117 | struct gfs2_inode *ip = GFS2_I(inode); |
1118 | int error; |
1119 | |
1120 | error = gfs2_dir_del(dip, dentry); |
1121 | if (error) |
1122 | return error; |
1123 | |
1124 | ip->i_entries = 0; |
1125 | inode_set_ctime_current(inode); |
1126 | if (S_ISDIR(inode->i_mode)) |
1127 | clear_nlink(inode); |
1128 | else |
1129 | drop_nlink(inode); |
1130 | mark_inode_dirty(inode); |
1131 | if (inode->i_nlink == 0) |
1132 | gfs2_unlink_di(inode); |
1133 | return 0; |
1134 | } |
1135 | |
1136 | |
1137 | /** |
1138 | * gfs2_unlink - Unlink an inode (this does rmdir as well) |
1139 | * @dir: The inode of the directory containing the inode to unlink |
1140 | * @dentry: The file itself |
1141 | * |
1142 | * This routine uses the type of the inode as a flag to figure out |
1143 | * whether this is an unlink or an rmdir. |
1144 | * |
1145 | * Returns: errno |
1146 | */ |
1147 | |
1148 | static int gfs2_unlink(struct inode *dir, struct dentry *dentry) |
1149 | { |
1150 | struct gfs2_inode *dip = GFS2_I(inode: dir); |
1151 | struct gfs2_sbd *sdp = GFS2_SB(inode: dir); |
1152 | struct inode *inode = d_inode(dentry); |
1153 | struct gfs2_inode *ip = GFS2_I(inode); |
1154 | struct gfs2_holder d_gh, r_gh, gh; |
1155 | struct gfs2_rgrpd *rgd; |
1156 | int error; |
1157 | |
1158 | error = gfs2_rindex_update(sdp); |
1159 | if (error) |
1160 | return error; |
1161 | |
1162 | error = -EROFS; |
1163 | |
1164 | gfs2_holder_init(gl: dip->i_gl, LM_ST_EXCLUSIVE, flags: 0, gh: &d_gh); |
1165 | gfs2_holder_init(gl: ip->i_gl, LM_ST_EXCLUSIVE, flags: 0, gh: &gh); |
1166 | |
1167 | rgd = gfs2_blk2rgrpd(sdp, blk: ip->i_no_addr, exact: 1); |
1168 | if (!rgd) |
1169 | goto out_inodes; |
1170 | |
1171 | gfs2_holder_init(gl: rgd->rd_gl, LM_ST_EXCLUSIVE, LM_FLAG_NODE_SCOPE, gh: &r_gh); |
1172 | |
1173 | |
1174 | error = gfs2_glock_nq(gh: &d_gh); |
1175 | if (error) |
1176 | goto out_parent; |
1177 | |
1178 | error = gfs2_glock_nq(gh: &gh); |
1179 | if (error) |
1180 | goto out_child; |
1181 | |
1182 | error = -ENOENT; |
1183 | if (inode->i_nlink == 0) |
1184 | goto out_rgrp; |
1185 | |
1186 | if (S_ISDIR(inode->i_mode)) { |
1187 | error = -ENOTEMPTY; |
1188 | if (ip->i_entries > 2 || inode->i_nlink > 2) |
1189 | goto out_rgrp; |
1190 | } |
1191 | |
1192 | error = gfs2_glock_nq(gh: &r_gh); /* rgrp */ |
1193 | if (error) |
1194 | goto out_rgrp; |
1195 | |
1196 | error = gfs2_unlink_ok(dip, name: &dentry->d_name, ip); |
1197 | if (error) |
1198 | goto out_gunlock; |
1199 | |
1200 | error = gfs2_trans_begin(sdp, blocks: 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, revokes: 0); |
1201 | if (error) |
1202 | goto out_gunlock; |
1203 | |
1204 | error = gfs2_unlink_inode(dip, dentry); |
1205 | gfs2_trans_end(sdp); |
1206 | |
1207 | out_gunlock: |
1208 | gfs2_glock_dq(gh: &r_gh); |
1209 | out_rgrp: |
1210 | gfs2_glock_dq(gh: &gh); |
1211 | out_child: |
1212 | gfs2_glock_dq(gh: &d_gh); |
1213 | out_parent: |
1214 | gfs2_holder_uninit(gh: &r_gh); |
1215 | out_inodes: |
1216 | gfs2_holder_uninit(gh: &gh); |
1217 | gfs2_holder_uninit(gh: &d_gh); |
1218 | return error; |
1219 | } |
1220 | |
1221 | /** |
1222 | * gfs2_symlink - Create a symlink |
1223 | * @idmap: idmap of the mount the inode was found from |
1224 | * @dir: The directory to create the symlink in |
1225 | * @dentry: The dentry to put the symlink in |
1226 | * @symname: The thing which the link points to |
1227 | * |
1228 | * Returns: errno |
1229 | */ |
1230 | |
1231 | static int gfs2_symlink(struct mnt_idmap *idmap, struct inode *dir, |
1232 | struct dentry *dentry, const char *symname) |
1233 | { |
1234 | unsigned int size; |
1235 | |
1236 | size = strlen(symname); |
1237 | if (size >= gfs2_max_stuffed_size(ip: GFS2_I(inode: dir))) |
1238 | return -ENAMETOOLONG; |
1239 | |
1240 | return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, dev: 0, symname, size, excl: 0); |
1241 | } |
1242 | |
1243 | /** |
1244 | * gfs2_mkdir - Make a directory |
1245 | * @idmap: idmap of the mount the inode was found from |
1246 | * @dir: The parent directory of the new one |
1247 | * @dentry: The dentry of the new directory |
1248 | * @mode: The mode of the new directory |
1249 | * |
1250 | * Returns: errno |
1251 | */ |
1252 | |
1253 | static int gfs2_mkdir(struct mnt_idmap *idmap, struct inode *dir, |
1254 | struct dentry *dentry, umode_t mode) |
1255 | { |
1256 | unsigned dsize = gfs2_max_stuffed_size(ip: GFS2_I(inode: dir)); |
1257 | return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, dev: 0, NULL, size: dsize, excl: 0); |
1258 | } |
1259 | |
1260 | /** |
1261 | * gfs2_mknod - Make a special file |
1262 | * @idmap: idmap of the mount the inode was found from |
1263 | * @dir: The directory in which the special file will reside |
1264 | * @dentry: The dentry of the special file |
1265 | * @mode: The mode of the special file |
1266 | * @dev: The device specification of the special file |
1267 | * |
1268 | */ |
1269 | |
1270 | static int gfs2_mknod(struct mnt_idmap *idmap, struct inode *dir, |
1271 | struct dentry *dentry, umode_t mode, dev_t dev) |
1272 | { |
1273 | return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, size: 0, excl: 0); |
1274 | } |
1275 | |
1276 | /** |
1277 | * gfs2_atomic_open - Atomically open a file |
1278 | * @dir: The directory |
1279 | * @dentry: The proposed new entry |
1280 | * @file: The proposed new struct file |
1281 | * @flags: open flags |
1282 | * @mode: File mode |
1283 | * |
1284 | * Returns: error code or 0 for success |
1285 | */ |
1286 | |
1287 | static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry, |
1288 | struct file *file, unsigned flags, |
1289 | umode_t mode) |
1290 | { |
1291 | struct dentry *d; |
1292 | bool excl = !!(flags & O_EXCL); |
1293 | |
1294 | if (!d_in_lookup(dentry)) |
1295 | goto skip_lookup; |
1296 | |
1297 | d = __gfs2_lookup(dir, dentry, file); |
1298 | if (IS_ERR(ptr: d)) |
1299 | return PTR_ERR(ptr: d); |
1300 | if (d != NULL) |
1301 | dentry = d; |
1302 | if (d_really_is_positive(dentry)) { |
1303 | if (!(file->f_mode & FMODE_OPENED)) |
1304 | return finish_no_open(file, dentry: d); |
1305 | dput(d); |
1306 | return excl && (flags & O_CREAT) ? -EEXIST : 0; |
1307 | } |
1308 | |
1309 | BUG_ON(d != NULL); |
1310 | |
1311 | skip_lookup: |
1312 | if (!(flags & O_CREAT)) |
1313 | return -ENOENT; |
1314 | |
1315 | return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, dev: 0, NULL, size: 0, excl); |
1316 | } |
1317 | |
1318 | /* |
1319 | * gfs2_ok_to_move - check if it's ok to move a directory to another directory |
1320 | * @this: move this |
1321 | * @to: to here |
1322 | * |
1323 | * Follow @to back to the root and make sure we don't encounter @this |
1324 | * Assumes we already hold the rename lock. |
1325 | * |
1326 | * Returns: errno |
1327 | */ |
1328 | |
1329 | static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to) |
1330 | { |
1331 | struct inode *dir = &to->i_inode; |
1332 | struct super_block *sb = dir->i_sb; |
1333 | struct inode *tmp; |
1334 | int error = 0; |
1335 | |
1336 | igrab(dir); |
1337 | |
1338 | for (;;) { |
1339 | if (dir == &this->i_inode) { |
1340 | error = -EINVAL; |
1341 | break; |
1342 | } |
1343 | if (dir == d_inode(dentry: sb->s_root)) { |
1344 | error = 0; |
1345 | break; |
1346 | } |
1347 | |
1348 | tmp = gfs2_lookupi(dir, name: &gfs2_qdotdot, is_root: 1); |
1349 | if (!tmp) { |
1350 | error = -ENOENT; |
1351 | break; |
1352 | } |
1353 | if (IS_ERR(ptr: tmp)) { |
1354 | error = PTR_ERR(ptr: tmp); |
1355 | break; |
1356 | } |
1357 | |
1358 | iput(dir); |
1359 | dir = tmp; |
1360 | } |
1361 | |
1362 | iput(dir); |
1363 | |
1364 | return error; |
1365 | } |
1366 | |
1367 | /** |
1368 | * update_moved_ino - Update an inode that's being moved |
1369 | * @ip: The inode being moved |
1370 | * @ndip: The parent directory of the new filename |
1371 | * @dir_rename: True of ip is a directory |
1372 | * |
1373 | * Returns: errno |
1374 | */ |
1375 | |
1376 | static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip, |
1377 | int dir_rename) |
1378 | { |
1379 | if (dir_rename) |
1380 | return gfs2_dir_mvino(dip: ip, filename: &gfs2_qdotdot, nip: ndip, DT_DIR); |
1381 | |
1382 | inode_set_ctime_current(inode: &ip->i_inode); |
1383 | mark_inode_dirty_sync(inode: &ip->i_inode); |
1384 | return 0; |
1385 | } |
1386 | |
1387 | |
1388 | /** |
1389 | * gfs2_rename - Rename a file |
1390 | * @odir: Parent directory of old file name |
1391 | * @odentry: The old dentry of the file |
1392 | * @ndir: Parent directory of new file name |
1393 | * @ndentry: The new dentry of the file |
1394 | * |
1395 | * Returns: errno |
1396 | */ |
1397 | |
1398 | static int gfs2_rename(struct inode *odir, struct dentry *odentry, |
1399 | struct inode *ndir, struct dentry *ndentry) |
1400 | { |
1401 | struct gfs2_inode *odip = GFS2_I(inode: odir); |
1402 | struct gfs2_inode *ndip = GFS2_I(inode: ndir); |
1403 | struct gfs2_inode *ip = GFS2_I(inode: d_inode(dentry: odentry)); |
1404 | struct gfs2_inode *nip = NULL; |
1405 | struct gfs2_sbd *sdp = GFS2_SB(inode: odir); |
1406 | struct gfs2_holder ghs[4], r_gh, rd_gh; |
1407 | struct gfs2_rgrpd *nrgd; |
1408 | unsigned int num_gh; |
1409 | int dir_rename = 0; |
1410 | struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, }; |
1411 | unsigned int x; |
1412 | int error; |
1413 | |
1414 | gfs2_holder_mark_uninitialized(gh: &r_gh); |
1415 | gfs2_holder_mark_uninitialized(gh: &rd_gh); |
1416 | if (d_really_is_positive(dentry: ndentry)) { |
1417 | nip = GFS2_I(inode: d_inode(dentry: ndentry)); |
1418 | if (ip == nip) |
1419 | return 0; |
1420 | } |
1421 | |
1422 | error = gfs2_rindex_update(sdp); |
1423 | if (error) |
1424 | return error; |
1425 | |
1426 | error = gfs2_qa_get(ip: ndip); |
1427 | if (error) |
1428 | return error; |
1429 | |
1430 | if (odip != ndip) { |
1431 | error = gfs2_glock_nq_init(gl: sdp->sd_rename_gl, LM_ST_EXCLUSIVE, |
1432 | flags: 0, gh: &r_gh); |
1433 | if (error) |
1434 | goto out; |
1435 | |
1436 | if (S_ISDIR(ip->i_inode.i_mode)) { |
1437 | dir_rename = 1; |
1438 | /* don't move a directory into its subdir */ |
1439 | error = gfs2_ok_to_move(this: ip, to: ndip); |
1440 | if (error) |
1441 | goto out_gunlock_r; |
1442 | } |
1443 | } |
1444 | |
1445 | num_gh = 1; |
1446 | gfs2_holder_init(gl: odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, gh: ghs); |
1447 | if (odip != ndip) { |
1448 | gfs2_holder_init(gl: ndip->i_gl, LM_ST_EXCLUSIVE,GL_ASYNC, |
1449 | gh: ghs + num_gh); |
1450 | num_gh++; |
1451 | } |
1452 | gfs2_holder_init(gl: ip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, gh: ghs + num_gh); |
1453 | num_gh++; |
1454 | |
1455 | if (nip) { |
1456 | gfs2_holder_init(gl: nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, |
1457 | gh: ghs + num_gh); |
1458 | num_gh++; |
1459 | } |
1460 | |
1461 | for (x = 0; x < num_gh; x++) { |
1462 | error = gfs2_glock_nq(gh: ghs + x); |
1463 | if (error) |
1464 | goto out_gunlock; |
1465 | } |
1466 | error = gfs2_glock_async_wait(num_gh, ghs); |
1467 | if (error) |
1468 | goto out_gunlock; |
1469 | |
1470 | if (nip) { |
1471 | /* Grab the resource group glock for unlink flag twiddling. |
1472 | * This is the case where the target dinode already exists |
1473 | * so we unlink before doing the rename. |
1474 | */ |
1475 | nrgd = gfs2_blk2rgrpd(sdp, blk: nip->i_no_addr, exact: 1); |
1476 | if (!nrgd) { |
1477 | error = -ENOENT; |
1478 | goto out_gunlock; |
1479 | } |
1480 | error = gfs2_glock_nq_init(gl: nrgd->rd_gl, LM_ST_EXCLUSIVE, |
1481 | LM_FLAG_NODE_SCOPE, gh: &rd_gh); |
1482 | if (error) |
1483 | goto out_gunlock; |
1484 | } |
1485 | |
1486 | error = -ENOENT; |
1487 | if (ip->i_inode.i_nlink == 0) |
1488 | goto out_gunlock; |
1489 | |
1490 | /* Check out the old directory */ |
1491 | |
1492 | error = gfs2_unlink_ok(dip: odip, name: &odentry->d_name, ip); |
1493 | if (error) |
1494 | goto out_gunlock; |
1495 | |
1496 | /* Check out the new directory */ |
1497 | |
1498 | if (nip) { |
1499 | error = gfs2_unlink_ok(dip: ndip, name: &ndentry->d_name, ip: nip); |
1500 | if (error) |
1501 | goto out_gunlock; |
1502 | |
1503 | if (nip->i_inode.i_nlink == 0) { |
1504 | error = -EAGAIN; |
1505 | goto out_gunlock; |
1506 | } |
1507 | |
1508 | if (S_ISDIR(nip->i_inode.i_mode)) { |
1509 | if (nip->i_entries < 2) { |
1510 | gfs2_consist_inode(nip); |
1511 | error = -EIO; |
1512 | goto out_gunlock; |
1513 | } |
1514 | if (nip->i_entries > 2) { |
1515 | error = -ENOTEMPTY; |
1516 | goto out_gunlock; |
1517 | } |
1518 | } |
1519 | } else { |
1520 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: ndir, |
1521 | MAY_WRITE | MAY_EXEC); |
1522 | if (error) |
1523 | goto out_gunlock; |
1524 | |
1525 | error = gfs2_dir_check(dir: ndir, filename: &ndentry->d_name, NULL); |
1526 | switch (error) { |
1527 | case -ENOENT: |
1528 | error = 0; |
1529 | break; |
1530 | case 0: |
1531 | error = -EEXIST; |
1532 | goto out_gunlock; |
1533 | default: |
1534 | goto out_gunlock; |
1535 | } |
1536 | |
1537 | if (odip != ndip) { |
1538 | if (!ndip->i_inode.i_nlink) { |
1539 | error = -ENOENT; |
1540 | goto out_gunlock; |
1541 | } |
1542 | if (ndip->i_entries == (u32)-1) { |
1543 | error = -EFBIG; |
1544 | goto out_gunlock; |
1545 | } |
1546 | if (S_ISDIR(ip->i_inode.i_mode) && |
1547 | ndip->i_inode.i_nlink == (u32)-1) { |
1548 | error = -EMLINK; |
1549 | goto out_gunlock; |
1550 | } |
1551 | } |
1552 | } |
1553 | |
1554 | /* Check out the dir to be renamed */ |
1555 | |
1556 | if (dir_rename) { |
1557 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: d_inode(dentry: odentry), |
1558 | MAY_WRITE); |
1559 | if (error) |
1560 | goto out_gunlock; |
1561 | } |
1562 | |
1563 | if (nip == NULL) { |
1564 | error = gfs2_diradd_alloc_required(dir: ndir, filename: &ndentry->d_name, da: &da); |
1565 | if (error) |
1566 | goto out_gunlock; |
1567 | } |
1568 | |
1569 | if (da.nr_blocks) { |
1570 | struct gfs2_alloc_parms ap = { .target = da.nr_blocks, }; |
1571 | error = gfs2_quota_lock_check(ip: ndip, ap: &ap); |
1572 | if (error) |
1573 | goto out_gunlock; |
1574 | |
1575 | error = gfs2_inplace_reserve(ip: ndip, ap: &ap); |
1576 | if (error) |
1577 | goto out_gunlock_q; |
1578 | |
1579 | error = gfs2_trans_begin(sdp, blocks: gfs2_trans_da_blks(dip: ndip, da: &da, nr_inodes: 4) + |
1580 | 4 * RES_LEAF + 4, revokes: 0); |
1581 | if (error) |
1582 | goto out_ipreserv; |
1583 | } else { |
1584 | error = gfs2_trans_begin(sdp, blocks: 4 * RES_DINODE + |
1585 | 5 * RES_LEAF + 4, revokes: 0); |
1586 | if (error) |
1587 | goto out_gunlock; |
1588 | } |
1589 | |
1590 | /* Remove the target file, if it exists */ |
1591 | |
1592 | if (nip) |
1593 | error = gfs2_unlink_inode(dip: ndip, dentry: ndentry); |
1594 | |
1595 | error = update_moved_ino(ip, ndip, dir_rename); |
1596 | if (error) |
1597 | goto out_end_trans; |
1598 | |
1599 | error = gfs2_dir_del(dip: odip, dentry: odentry); |
1600 | if (error) |
1601 | goto out_end_trans; |
1602 | |
1603 | error = gfs2_dir_add(inode: ndir, filename: &ndentry->d_name, ip, da: &da); |
1604 | if (error) |
1605 | goto out_end_trans; |
1606 | |
1607 | out_end_trans: |
1608 | gfs2_trans_end(sdp); |
1609 | out_ipreserv: |
1610 | if (da.nr_blocks) |
1611 | gfs2_inplace_release(ip: ndip); |
1612 | out_gunlock_q: |
1613 | if (da.nr_blocks) |
1614 | gfs2_quota_unlock(ip: ndip); |
1615 | out_gunlock: |
1616 | gfs2_dir_no_add(da: &da); |
1617 | if (gfs2_holder_initialized(gh: &rd_gh)) |
1618 | gfs2_glock_dq_uninit(gh: &rd_gh); |
1619 | |
1620 | while (x--) { |
1621 | if (gfs2_holder_queued(gh: ghs + x)) |
1622 | gfs2_glock_dq(gh: ghs + x); |
1623 | gfs2_holder_uninit(gh: ghs + x); |
1624 | } |
1625 | out_gunlock_r: |
1626 | if (gfs2_holder_initialized(gh: &r_gh)) |
1627 | gfs2_glock_dq_uninit(gh: &r_gh); |
1628 | out: |
1629 | gfs2_qa_put(ip: ndip); |
1630 | return error; |
1631 | } |
1632 | |
1633 | /** |
1634 | * gfs2_exchange - exchange two files |
1635 | * @odir: Parent directory of old file name |
1636 | * @odentry: The old dentry of the file |
1637 | * @ndir: Parent directory of new file name |
1638 | * @ndentry: The new dentry of the file |
1639 | * @flags: The rename flags |
1640 | * |
1641 | * Returns: errno |
1642 | */ |
1643 | |
1644 | static int gfs2_exchange(struct inode *odir, struct dentry *odentry, |
1645 | struct inode *ndir, struct dentry *ndentry, |
1646 | unsigned int flags) |
1647 | { |
1648 | struct gfs2_inode *odip = GFS2_I(inode: odir); |
1649 | struct gfs2_inode *ndip = GFS2_I(inode: ndir); |
1650 | struct gfs2_inode *oip = GFS2_I(inode: odentry->d_inode); |
1651 | struct gfs2_inode *nip = GFS2_I(inode: ndentry->d_inode); |
1652 | struct gfs2_sbd *sdp = GFS2_SB(inode: odir); |
1653 | struct gfs2_holder ghs[4], r_gh; |
1654 | unsigned int num_gh; |
1655 | unsigned int x; |
1656 | umode_t old_mode = oip->i_inode.i_mode; |
1657 | umode_t new_mode = nip->i_inode.i_mode; |
1658 | int error; |
1659 | |
1660 | gfs2_holder_mark_uninitialized(gh: &r_gh); |
1661 | error = gfs2_rindex_update(sdp); |
1662 | if (error) |
1663 | return error; |
1664 | |
1665 | if (odip != ndip) { |
1666 | error = gfs2_glock_nq_init(gl: sdp->sd_rename_gl, LM_ST_EXCLUSIVE, |
1667 | flags: 0, gh: &r_gh); |
1668 | if (error) |
1669 | goto out; |
1670 | |
1671 | if (S_ISDIR(old_mode)) { |
1672 | /* don't move a directory into its subdir */ |
1673 | error = gfs2_ok_to_move(this: oip, to: ndip); |
1674 | if (error) |
1675 | goto out_gunlock_r; |
1676 | } |
1677 | |
1678 | if (S_ISDIR(new_mode)) { |
1679 | /* don't move a directory into its subdir */ |
1680 | error = gfs2_ok_to_move(this: nip, to: odip); |
1681 | if (error) |
1682 | goto out_gunlock_r; |
1683 | } |
1684 | } |
1685 | |
1686 | num_gh = 1; |
1687 | gfs2_holder_init(gl: odip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, gh: ghs); |
1688 | if (odip != ndip) { |
1689 | gfs2_holder_init(gl: ndip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, |
1690 | gh: ghs + num_gh); |
1691 | num_gh++; |
1692 | } |
1693 | gfs2_holder_init(gl: oip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, gh: ghs + num_gh); |
1694 | num_gh++; |
1695 | |
1696 | gfs2_holder_init(gl: nip->i_gl, LM_ST_EXCLUSIVE, GL_ASYNC, gh: ghs + num_gh); |
1697 | num_gh++; |
1698 | |
1699 | for (x = 0; x < num_gh; x++) { |
1700 | error = gfs2_glock_nq(gh: ghs + x); |
1701 | if (error) |
1702 | goto out_gunlock; |
1703 | } |
1704 | |
1705 | error = gfs2_glock_async_wait(num_gh, ghs); |
1706 | if (error) |
1707 | goto out_gunlock; |
1708 | |
1709 | error = -ENOENT; |
1710 | if (oip->i_inode.i_nlink == 0 || nip->i_inode.i_nlink == 0) |
1711 | goto out_gunlock; |
1712 | |
1713 | error = gfs2_unlink_ok(dip: odip, name: &odentry->d_name, ip: oip); |
1714 | if (error) |
1715 | goto out_gunlock; |
1716 | error = gfs2_unlink_ok(dip: ndip, name: &ndentry->d_name, ip: nip); |
1717 | if (error) |
1718 | goto out_gunlock; |
1719 | |
1720 | if (S_ISDIR(old_mode)) { |
1721 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: odentry->d_inode, |
1722 | MAY_WRITE); |
1723 | if (error) |
1724 | goto out_gunlock; |
1725 | } |
1726 | if (S_ISDIR(new_mode)) { |
1727 | error = gfs2_permission(idmap: &nop_mnt_idmap, inode: ndentry->d_inode, |
1728 | MAY_WRITE); |
1729 | if (error) |
1730 | goto out_gunlock; |
1731 | } |
1732 | error = gfs2_trans_begin(sdp, blocks: 4 * RES_DINODE + 4 * RES_LEAF, revokes: 0); |
1733 | if (error) |
1734 | goto out_gunlock; |
1735 | |
1736 | error = update_moved_ino(ip: oip, ndip, S_ISDIR(old_mode)); |
1737 | if (error) |
1738 | goto out_end_trans; |
1739 | |
1740 | error = update_moved_ino(ip: nip, ndip: odip, S_ISDIR(new_mode)); |
1741 | if (error) |
1742 | goto out_end_trans; |
1743 | |
1744 | error = gfs2_dir_mvino(dip: ndip, filename: &ndentry->d_name, nip: oip, |
1745 | IF2DT(old_mode)); |
1746 | if (error) |
1747 | goto out_end_trans; |
1748 | |
1749 | error = gfs2_dir_mvino(dip: odip, filename: &odentry->d_name, nip, |
1750 | IF2DT(new_mode)); |
1751 | if (error) |
1752 | goto out_end_trans; |
1753 | |
1754 | if (odip != ndip) { |
1755 | if (S_ISDIR(new_mode) && !S_ISDIR(old_mode)) { |
1756 | inc_nlink(inode: &odip->i_inode); |
1757 | drop_nlink(inode: &ndip->i_inode); |
1758 | } else if (S_ISDIR(old_mode) && !S_ISDIR(new_mode)) { |
1759 | inc_nlink(inode: &ndip->i_inode); |
1760 | drop_nlink(inode: &odip->i_inode); |
1761 | } |
1762 | } |
1763 | mark_inode_dirty(inode: &ndip->i_inode); |
1764 | if (odip != ndip) |
1765 | mark_inode_dirty(inode: &odip->i_inode); |
1766 | |
1767 | out_end_trans: |
1768 | gfs2_trans_end(sdp); |
1769 | out_gunlock: |
1770 | while (x--) { |
1771 | if (gfs2_holder_queued(gh: ghs + x)) |
1772 | gfs2_glock_dq(gh: ghs + x); |
1773 | gfs2_holder_uninit(gh: ghs + x); |
1774 | } |
1775 | out_gunlock_r: |
1776 | if (gfs2_holder_initialized(gh: &r_gh)) |
1777 | gfs2_glock_dq_uninit(gh: &r_gh); |
1778 | out: |
1779 | return error; |
1780 | } |
1781 | |
1782 | static int gfs2_rename2(struct mnt_idmap *idmap, struct inode *odir, |
1783 | struct dentry *odentry, struct inode *ndir, |
1784 | struct dentry *ndentry, unsigned int flags) |
1785 | { |
1786 | flags &= ~RENAME_NOREPLACE; |
1787 | |
1788 | if (flags & ~RENAME_EXCHANGE) |
1789 | return -EINVAL; |
1790 | |
1791 | if (flags & RENAME_EXCHANGE) |
1792 | return gfs2_exchange(odir, odentry, ndir, ndentry, flags); |
1793 | |
1794 | return gfs2_rename(odir, odentry, ndir, ndentry); |
1795 | } |
1796 | |
1797 | /** |
1798 | * gfs2_get_link - Follow a symbolic link |
1799 | * @dentry: The dentry of the link |
1800 | * @inode: The inode of the link |
1801 | * @done: destructor for return value |
1802 | * |
1803 | * This can handle symlinks of any size. |
1804 | * |
1805 | * Returns: 0 on success or error code |
1806 | */ |
1807 | |
1808 | static const char *gfs2_get_link(struct dentry *dentry, |
1809 | struct inode *inode, |
1810 | struct delayed_call *done) |
1811 | { |
1812 | struct gfs2_inode *ip = GFS2_I(inode); |
1813 | struct gfs2_holder i_gh; |
1814 | struct buffer_head *dibh; |
1815 | unsigned int size; |
1816 | char *buf; |
1817 | int error; |
1818 | |
1819 | if (!dentry) |
1820 | return ERR_PTR(error: -ECHILD); |
1821 | |
1822 | gfs2_holder_init(gl: ip->i_gl, LM_ST_SHARED, flags: 0, gh: &i_gh); |
1823 | error = gfs2_glock_nq(gh: &i_gh); |
1824 | if (error) { |
1825 | gfs2_holder_uninit(gh: &i_gh); |
1826 | return ERR_PTR(error); |
1827 | } |
1828 | |
1829 | size = (unsigned int)i_size_read(inode: &ip->i_inode); |
1830 | if (size == 0) { |
1831 | gfs2_consist_inode(ip); |
1832 | buf = ERR_PTR(error: -EIO); |
1833 | goto out; |
1834 | } |
1835 | |
1836 | error = gfs2_meta_inode_buffer(ip, bhp: &dibh); |
1837 | if (error) { |
1838 | buf = ERR_PTR(error); |
1839 | goto out; |
1840 | } |
1841 | |
1842 | buf = kzalloc(size: size + 1, GFP_NOFS); |
1843 | if (!buf) |
1844 | buf = ERR_PTR(error: -ENOMEM); |
1845 | else |
1846 | memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size); |
1847 | brelse(bh: dibh); |
1848 | out: |
1849 | gfs2_glock_dq_uninit(gh: &i_gh); |
1850 | if (!IS_ERR(ptr: buf)) |
1851 | set_delayed_call(call: done, fn: kfree_link, arg: buf); |
1852 | return buf; |
1853 | } |
1854 | |
1855 | /** |
1856 | * gfs2_permission |
1857 | * @idmap: idmap of the mount the inode was found from |
1858 | * @inode: The inode |
1859 | * @mask: The mask to be tested |
1860 | * |
1861 | * This may be called from the VFS directly, or from within GFS2 with the |
1862 | * inode locked, so we look to see if the glock is already locked and only |
1863 | * lock the glock if its not already been done. |
1864 | * |
1865 | * Returns: errno |
1866 | */ |
1867 | |
1868 | int gfs2_permission(struct mnt_idmap *idmap, struct inode *inode, |
1869 | int mask) |
1870 | { |
1871 | int may_not_block = mask & MAY_NOT_BLOCK; |
1872 | struct gfs2_inode *ip; |
1873 | struct gfs2_holder i_gh; |
1874 | struct gfs2_glock *gl; |
1875 | int error; |
1876 | |
1877 | gfs2_holder_mark_uninitialized(gh: &i_gh); |
1878 | ip = GFS2_I(inode); |
1879 | gl = rcu_dereference_check(ip->i_gl, !may_not_block); |
1880 | if (unlikely(!gl)) { |
1881 | /* inode is getting torn down, must be RCU mode */ |
1882 | WARN_ON_ONCE(!may_not_block); |
1883 | return -ECHILD; |
1884 | } |
1885 | if (gfs2_glock_is_locked_by_me(gl) == NULL) { |
1886 | if (may_not_block) |
1887 | return -ECHILD; |
1888 | error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, gh: &i_gh); |
1889 | if (error) |
1890 | return error; |
1891 | } |
1892 | |
1893 | if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode)) |
1894 | error = -EPERM; |
1895 | else |
1896 | error = generic_permission(&nop_mnt_idmap, inode, mask); |
1897 | if (gfs2_holder_initialized(gh: &i_gh)) |
1898 | gfs2_glock_dq_uninit(gh: &i_gh); |
1899 | |
1900 | return error; |
1901 | } |
1902 | |
1903 | static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr) |
1904 | { |
1905 | setattr_copy(&nop_mnt_idmap, inode, attr); |
1906 | mark_inode_dirty(inode); |
1907 | return 0; |
1908 | } |
1909 | |
1910 | static int gfs2_setattr_simple(struct inode *inode, struct iattr *attr) |
1911 | { |
1912 | int error; |
1913 | |
1914 | if (current->journal_info) |
1915 | return __gfs2_setattr_simple(inode, attr); |
1916 | |
1917 | error = gfs2_trans_begin(sdp: GFS2_SB(inode), RES_DINODE, revokes: 0); |
1918 | if (error) |
1919 | return error; |
1920 | |
1921 | error = __gfs2_setattr_simple(inode, attr); |
1922 | gfs2_trans_end(sdp: GFS2_SB(inode)); |
1923 | return error; |
1924 | } |
1925 | |
1926 | static int setattr_chown(struct inode *inode, struct iattr *attr) |
1927 | { |
1928 | struct gfs2_inode *ip = GFS2_I(inode); |
1929 | struct gfs2_sbd *sdp = GFS2_SB(inode); |
1930 | kuid_t ouid, nuid; |
1931 | kgid_t ogid, ngid; |
1932 | int error; |
1933 | struct gfs2_alloc_parms ap = {}; |
1934 | |
1935 | ouid = inode->i_uid; |
1936 | ogid = inode->i_gid; |
1937 | nuid = attr->ia_uid; |
1938 | ngid = attr->ia_gid; |
1939 | |
1940 | if (!(attr->ia_valid & ATTR_UID) || uid_eq(left: ouid, right: nuid)) |
1941 | ouid = nuid = NO_UID_QUOTA_CHANGE; |
1942 | if (!(attr->ia_valid & ATTR_GID) || gid_eq(left: ogid, right: ngid)) |
1943 | ogid = ngid = NO_GID_QUOTA_CHANGE; |
1944 | error = gfs2_qa_get(ip); |
1945 | if (error) |
1946 | return error; |
1947 | |
1948 | error = gfs2_rindex_update(sdp); |
1949 | if (error) |
1950 | goto out; |
1951 | |
1952 | error = gfs2_quota_lock(ip, uid: nuid, gid: ngid); |
1953 | if (error) |
1954 | goto out; |
1955 | |
1956 | ap.target = gfs2_get_inode_blocks(inode: &ip->i_inode); |
1957 | |
1958 | if (!uid_eq(left: ouid, NO_UID_QUOTA_CHANGE) || |
1959 | !gid_eq(left: ogid, NO_GID_QUOTA_CHANGE)) { |
1960 | error = gfs2_quota_check(ip, uid: nuid, gid: ngid, ap: &ap); |
1961 | if (error) |
1962 | goto out_gunlock_q; |
1963 | } |
1964 | |
1965 | error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, revokes: 0); |
1966 | if (error) |
1967 | goto out_gunlock_q; |
1968 | |
1969 | error = gfs2_setattr_simple(inode, attr); |
1970 | if (error) |
1971 | goto out_end_trans; |
1972 | |
1973 | if (!uid_eq(left: ouid, NO_UID_QUOTA_CHANGE) || |
1974 | !gid_eq(left: ogid, NO_GID_QUOTA_CHANGE)) { |
1975 | gfs2_quota_change(ip, change: -(s64)ap.target, uid: ouid, gid: ogid); |
1976 | gfs2_quota_change(ip, change: ap.target, uid: nuid, gid: ngid); |
1977 | } |
1978 | |
1979 | out_end_trans: |
1980 | gfs2_trans_end(sdp); |
1981 | out_gunlock_q: |
1982 | gfs2_quota_unlock(ip); |
1983 | out: |
1984 | gfs2_qa_put(ip); |
1985 | return error; |
1986 | } |
1987 | |
1988 | /** |
1989 | * gfs2_setattr - Change attributes on an inode |
1990 | * @idmap: idmap of the mount the inode was found from |
1991 | * @dentry: The dentry which is changing |
1992 | * @attr: The structure describing the change |
1993 | * |
1994 | * The VFS layer wants to change one or more of an inodes attributes. Write |
1995 | * that change out to disk. |
1996 | * |
1997 | * Returns: errno |
1998 | */ |
1999 | |
2000 | static int gfs2_setattr(struct mnt_idmap *idmap, |
2001 | struct dentry *dentry, struct iattr *attr) |
2002 | { |
2003 | struct inode *inode = d_inode(dentry); |
2004 | struct gfs2_inode *ip = GFS2_I(inode); |
2005 | struct gfs2_holder i_gh; |
2006 | int error; |
2007 | |
2008 | error = gfs2_qa_get(ip); |
2009 | if (error) |
2010 | return error; |
2011 | |
2012 | error = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_EXCLUSIVE, flags: 0, gh: &i_gh); |
2013 | if (error) |
2014 | goto out; |
2015 | |
2016 | error = may_setattr(idmap: &nop_mnt_idmap, inode, ia_valid: attr->ia_valid); |
2017 | if (error) |
2018 | goto error; |
2019 | |
2020 | error = setattr_prepare(&nop_mnt_idmap, dentry, attr); |
2021 | if (error) |
2022 | goto error; |
2023 | |
2024 | if (attr->ia_valid & ATTR_SIZE) |
2025 | error = gfs2_setattr_size(inode, size: attr->ia_size); |
2026 | else if (attr->ia_valid & (ATTR_UID | ATTR_GID)) |
2027 | error = setattr_chown(inode, attr); |
2028 | else { |
2029 | error = gfs2_setattr_simple(inode, attr); |
2030 | if (!error && attr->ia_valid & ATTR_MODE) |
2031 | error = posix_acl_chmod(&nop_mnt_idmap, dentry, |
2032 | inode->i_mode); |
2033 | } |
2034 | |
2035 | error: |
2036 | if (!error) |
2037 | mark_inode_dirty(inode); |
2038 | gfs2_glock_dq_uninit(gh: &i_gh); |
2039 | out: |
2040 | gfs2_qa_put(ip); |
2041 | return error; |
2042 | } |
2043 | |
2044 | /** |
2045 | * gfs2_getattr - Read out an inode's attributes |
2046 | * @idmap: idmap of the mount the inode was found from |
2047 | * @path: Object to query |
2048 | * @stat: The inode's stats |
2049 | * @request_mask: Mask of STATX_xxx flags indicating the caller's interests |
2050 | * @flags: AT_STATX_xxx setting |
2051 | * |
2052 | * This may be called from the VFS directly, or from within GFS2 with the |
2053 | * inode locked, so we look to see if the glock is already locked and only |
2054 | * lock the glock if its not already been done. Note that its the NFS |
2055 | * readdirplus operation which causes this to be called (from filldir) |
2056 | * with the glock already held. |
2057 | * |
2058 | * Returns: errno |
2059 | */ |
2060 | |
2061 | static int gfs2_getattr(struct mnt_idmap *idmap, |
2062 | const struct path *path, struct kstat *stat, |
2063 | u32 request_mask, unsigned int flags) |
2064 | { |
2065 | struct inode *inode = d_inode(dentry: path->dentry); |
2066 | struct gfs2_inode *ip = GFS2_I(inode); |
2067 | struct gfs2_holder gh; |
2068 | u32 gfsflags; |
2069 | int error; |
2070 | |
2071 | gfs2_holder_mark_uninitialized(gh: &gh); |
2072 | if (gfs2_glock_is_locked_by_me(gl: ip->i_gl) == NULL) { |
2073 | error = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, gh: &gh); |
2074 | if (error) |
2075 | return error; |
2076 | } |
2077 | |
2078 | gfsflags = ip->i_diskflags; |
2079 | if (gfsflags & GFS2_DIF_APPENDONLY) |
2080 | stat->attributes |= STATX_ATTR_APPEND; |
2081 | if (gfsflags & GFS2_DIF_IMMUTABLE) |
2082 | stat->attributes |= STATX_ATTR_IMMUTABLE; |
2083 | |
2084 | stat->attributes_mask |= (STATX_ATTR_APPEND | |
2085 | STATX_ATTR_COMPRESSED | |
2086 | STATX_ATTR_ENCRYPTED | |
2087 | STATX_ATTR_IMMUTABLE | |
2088 | STATX_ATTR_NODUMP); |
2089 | |
2090 | generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat); |
2091 | |
2092 | if (gfs2_holder_initialized(gh: &gh)) |
2093 | gfs2_glock_dq_uninit(gh: &gh); |
2094 | |
2095 | return 0; |
2096 | } |
2097 | |
2098 | static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, |
2099 | u64 start, u64 len) |
2100 | { |
2101 | struct gfs2_inode *ip = GFS2_I(inode); |
2102 | struct gfs2_holder gh; |
2103 | int ret; |
2104 | |
2105 | inode_lock_shared(inode); |
2106 | |
2107 | ret = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_SHARED, flags: 0, gh: &gh); |
2108 | if (ret) |
2109 | goto out; |
2110 | |
2111 | ret = iomap_fiemap(inode, fieinfo, start, len, ops: &gfs2_iomap_ops); |
2112 | |
2113 | gfs2_glock_dq_uninit(gh: &gh); |
2114 | |
2115 | out: |
2116 | inode_unlock_shared(inode); |
2117 | return ret; |
2118 | } |
2119 | |
2120 | loff_t gfs2_seek_data(struct file *file, loff_t offset) |
2121 | { |
2122 | struct inode *inode = file->f_mapping->host; |
2123 | struct gfs2_inode *ip = GFS2_I(inode); |
2124 | struct gfs2_holder gh; |
2125 | loff_t ret; |
2126 | |
2127 | inode_lock_shared(inode); |
2128 | ret = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_SHARED, flags: 0, gh: &gh); |
2129 | if (!ret) |
2130 | ret = iomap_seek_data(inode, offset, ops: &gfs2_iomap_ops); |
2131 | gfs2_glock_dq_uninit(gh: &gh); |
2132 | inode_unlock_shared(inode); |
2133 | |
2134 | if (ret < 0) |
2135 | return ret; |
2136 | return vfs_setpos(file, offset: ret, maxsize: inode->i_sb->s_maxbytes); |
2137 | } |
2138 | |
2139 | loff_t gfs2_seek_hole(struct file *file, loff_t offset) |
2140 | { |
2141 | struct inode *inode = file->f_mapping->host; |
2142 | struct gfs2_inode *ip = GFS2_I(inode); |
2143 | struct gfs2_holder gh; |
2144 | loff_t ret; |
2145 | |
2146 | inode_lock_shared(inode); |
2147 | ret = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_SHARED, flags: 0, gh: &gh); |
2148 | if (!ret) |
2149 | ret = iomap_seek_hole(inode, offset, ops: &gfs2_iomap_ops); |
2150 | gfs2_glock_dq_uninit(gh: &gh); |
2151 | inode_unlock_shared(inode); |
2152 | |
2153 | if (ret < 0) |
2154 | return ret; |
2155 | return vfs_setpos(file, offset: ret, maxsize: inode->i_sb->s_maxbytes); |
2156 | } |
2157 | |
2158 | static int gfs2_update_time(struct inode *inode, int flags) |
2159 | { |
2160 | struct gfs2_inode *ip = GFS2_I(inode); |
2161 | struct gfs2_glock *gl = ip->i_gl; |
2162 | struct gfs2_holder *gh; |
2163 | int error; |
2164 | |
2165 | gh = gfs2_glock_is_locked_by_me(gl); |
2166 | if (gh && gl->gl_state != LM_ST_EXCLUSIVE) { |
2167 | gfs2_glock_dq(gh); |
2168 | gfs2_holder_reinit(LM_ST_EXCLUSIVE, flags: 0, gh); |
2169 | error = gfs2_glock_nq(gh); |
2170 | if (error) |
2171 | return error; |
2172 | } |
2173 | generic_update_time(inode, flags); |
2174 | return 0; |
2175 | } |
2176 | |
2177 | static const struct inode_operations gfs2_file_iops = { |
2178 | .permission = gfs2_permission, |
2179 | .setattr = gfs2_setattr, |
2180 | .getattr = gfs2_getattr, |
2181 | .listxattr = gfs2_listxattr, |
2182 | .fiemap = gfs2_fiemap, |
2183 | .get_inode_acl = gfs2_get_acl, |
2184 | .set_acl = gfs2_set_acl, |
2185 | .update_time = gfs2_update_time, |
2186 | .fileattr_get = gfs2_fileattr_get, |
2187 | .fileattr_set = gfs2_fileattr_set, |
2188 | }; |
2189 | |
2190 | static const struct inode_operations gfs2_dir_iops = { |
2191 | .create = gfs2_create, |
2192 | .lookup = gfs2_lookup, |
2193 | .link = gfs2_link, |
2194 | .unlink = gfs2_unlink, |
2195 | .symlink = gfs2_symlink, |
2196 | .mkdir = gfs2_mkdir, |
2197 | .rmdir = gfs2_unlink, |
2198 | .mknod = gfs2_mknod, |
2199 | .rename = gfs2_rename2, |
2200 | .permission = gfs2_permission, |
2201 | .setattr = gfs2_setattr, |
2202 | .getattr = gfs2_getattr, |
2203 | .listxattr = gfs2_listxattr, |
2204 | .fiemap = gfs2_fiemap, |
2205 | .get_inode_acl = gfs2_get_acl, |
2206 | .set_acl = gfs2_set_acl, |
2207 | .update_time = gfs2_update_time, |
2208 | .atomic_open = gfs2_atomic_open, |
2209 | .fileattr_get = gfs2_fileattr_get, |
2210 | .fileattr_set = gfs2_fileattr_set, |
2211 | }; |
2212 | |
2213 | static const struct inode_operations gfs2_symlink_iops = { |
2214 | .get_link = gfs2_get_link, |
2215 | .permission = gfs2_permission, |
2216 | .setattr = gfs2_setattr, |
2217 | .getattr = gfs2_getattr, |
2218 | .listxattr = gfs2_listxattr, |
2219 | .fiemap = gfs2_fiemap, |
2220 | }; |
2221 | |
2222 | |