aboutsummaryrefslogtreecommitdiffstats
path: root/fs/gfs2/inode.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/gfs2/inode.c')
-rw-r--r--fs/gfs2/inode.c1751
1 files changed, 1271 insertions, 480 deletions
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 08140f185a37..03e0c529063e 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -1,23 +1,25 @@
1/* 1/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This copyrighted material is made available to anyone wishing to use, 5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions 6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2. 7 * of the GNU General Public License version 2.
8 */ 8 */
9 9
10#include <linux/sched.h>
11#include <linux/slab.h> 10#include <linux/slab.h>
12#include <linux/spinlock.h> 11#include <linux/spinlock.h>
13#include <linux/completion.h> 12#include <linux/completion.h>
14#include <linux/buffer_head.h> 13#include <linux/buffer_head.h>
14#include <linux/namei.h>
15#include <linux/mm.h>
16#include <linux/xattr.h>
15#include <linux/posix_acl.h> 17#include <linux/posix_acl.h>
16#include <linux/sort.h>
17#include <linux/gfs2_ondisk.h> 18#include <linux/gfs2_ondisk.h>
18#include <linux/crc32.h> 19#include <linux/crc32.h>
20#include <linux/fiemap.h>
19#include <linux/security.h> 21#include <linux/security.h>
20#include <linux/time.h> 22#include <asm/uaccess.h>
21 23
22#include "gfs2.h" 24#include "gfs2.h"
23#include "incore.h" 25#include "incore.h"
@@ -26,65 +28,29 @@
26#include "dir.h" 28#include "dir.h"
27#include "xattr.h" 29#include "xattr.h"
28#include "glock.h" 30#include "glock.h"
29#include "glops.h"
30#include "inode.h" 31#include "inode.h"
31#include "log.h"
32#include "meta_io.h" 32#include "meta_io.h"
33#include "quota.h" 33#include "quota.h"
34#include "rgrp.h" 34#include "rgrp.h"
35#include "trans.h" 35#include "trans.h"
36#include "util.h" 36#include "util.h"
37 37#include "super.h"
38struct gfs2_inum_range_host { 38#include "glops.h"
39 u64 ir_start;
40 u64 ir_length;
41};
42
43static int iget_test(struct inode *inode, void *opaque)
44{
45 struct gfs2_inode *ip = GFS2_I(inode);
46 u64 *no_addr = opaque;
47
48 if (ip->i_no_addr == *no_addr)
49 return 1;
50
51 return 0;
52}
53
54static int iget_set(struct inode *inode, void *opaque)
55{
56 struct gfs2_inode *ip = GFS2_I(inode);
57 u64 *no_addr = opaque;
58
59 inode->i_ino = (unsigned long)*no_addr;
60 ip->i_no_addr = *no_addr;
61 return 0;
62}
63
64struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
65{
66 unsigned long hash = (unsigned long)no_addr;
67 return ilookup5(sb, hash, iget_test, &no_addr);
68}
69
70static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
71{
72 unsigned long hash = (unsigned long)no_addr;
73 return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
74}
75 39
76struct gfs2_skip_data { 40struct gfs2_skip_data {
77 u64 no_addr; 41 u64 no_addr;
78 int skipped; 42 int skipped;
43 int non_block;
79}; 44};
80 45
81static int iget_skip_test(struct inode *inode, void *opaque) 46static int iget_test(struct inode *inode, void *opaque)
82{ 47{
83 struct gfs2_inode *ip = GFS2_I(inode); 48 struct gfs2_inode *ip = GFS2_I(inode);
84 struct gfs2_skip_data *data = opaque; 49 struct gfs2_skip_data *data = opaque;
85 50
86 if (ip->i_no_addr == data->no_addr) { 51 if (ip->i_no_addr == data->no_addr) {
87 if (inode->i_state & (I_FREEING|I_WILL_FREE)){ 52 if (data->non_block &&
53 inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
88 data->skipped = 1; 54 data->skipped = 1;
89 return 0; 55 return 0;
90 } 56 }
@@ -93,40 +59,50 @@ static int iget_skip_test(struct inode *inode, void *opaque)
93 return 0; 59 return 0;
94} 60}
95 61
96static int iget_skip_set(struct inode *inode, void *opaque) 62static int iget_set(struct inode *inode, void *opaque)
97{ 63{
98 struct gfs2_inode *ip = GFS2_I(inode); 64 struct gfs2_inode *ip = GFS2_I(inode);
99 struct gfs2_skip_data *data = opaque; 65 struct gfs2_skip_data *data = opaque;
100 66
101 if (data->skipped) 67 if (data->skipped)
102 return 1; 68 return -ENOENT;
103 inode->i_ino = (unsigned long)(data->no_addr); 69 inode->i_ino = (unsigned long)(data->no_addr);
104 ip->i_no_addr = data->no_addr; 70 ip->i_no_addr = data->no_addr;
105 return 0; 71 return 0;
106} 72}
107 73
108static struct inode *gfs2_iget_skip(struct super_block *sb, 74struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
109 u64 no_addr) 75{
76 unsigned long hash = (unsigned long)no_addr;
77 struct gfs2_skip_data data;
78
79 data.no_addr = no_addr;
80 data.skipped = 0;
81 data.non_block = non_block;
82 return ilookup5(sb, hash, iget_test, &data);
83}
84
85static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
86 int non_block)
110{ 87{
111 struct gfs2_skip_data data; 88 struct gfs2_skip_data data;
112 unsigned long hash = (unsigned long)no_addr; 89 unsigned long hash = (unsigned long)no_addr;
113 90
114 data.no_addr = no_addr; 91 data.no_addr = no_addr;
115 data.skipped = 0; 92 data.skipped = 0;
116 return iget5_locked(sb, hash, iget_skip_test, iget_skip_set, &data); 93 data.non_block = non_block;
94 return iget5_locked(sb, hash, iget_test, iget_set, &data);
117} 95}
118 96
119/** 97/**
120 * GFS2 lookup code fills in vfs inode contents based on info obtained 98 * gfs2_set_iop - Sets inode operations
121 * from directory entry inside gfs2_inode_lookup(). This has caused issues 99 * @inode: The inode with correct i_mode filled in
122 * with NFS code path since its get_dentry routine doesn't have the relevant
123 * directory entry when gfs2_inode_lookup() is invoked. Part of the code
124 * segment inside gfs2_inode_lookup code needs to get moved around.
125 * 100 *
126 * Clears I_NEW as well. 101 * GFS2 lookup code fills in vfs inode contents based on info obtained
127 **/ 102 * from directory entry inside gfs2_inode_lookup().
103 */
128 104
129void gfs2_set_iop(struct inode *inode) 105static void gfs2_set_iop(struct inode *inode)
130{ 106{
131 struct gfs2_sbd *sdp = GFS2_SB(inode); 107 struct gfs2_sbd *sdp = GFS2_SB(inode);
132 umode_t mode = inode->i_mode; 108 umode_t mode = inode->i_mode;
@@ -149,8 +125,6 @@ void gfs2_set_iop(struct inode *inode)
149 inode->i_op = &gfs2_file_iops; 125 inode->i_op = &gfs2_file_iops;
150 init_special_inode(inode, inode->i_mode, inode->i_rdev); 126 init_special_inode(inode, inode->i_mode, inode->i_rdev);
151 } 127 }
152
153 unlock_new_inode(inode);
154} 128}
155 129
156/** 130/**
@@ -158,21 +132,20 @@ void gfs2_set_iop(struct inode *inode)
158 * @sb: The super block 132 * @sb: The super block
159 * @no_addr: The inode number 133 * @no_addr: The inode number
160 * @type: The type of the inode 134 * @type: The type of the inode
135 * non_block: Can we block on inodes that are being freed?
161 * 136 *
162 * Returns: A VFS inode, or an error 137 * Returns: A VFS inode, or an error
163 */ 138 */
164 139
165struct inode *gfs2_inode_lookup(struct super_block *sb, 140struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
166 unsigned int type, 141 u64 no_addr, u64 no_formal_ino, int non_block)
167 u64 no_addr,
168 u64 no_formal_ino)
169{ 142{
170 struct inode *inode; 143 struct inode *inode;
171 struct gfs2_inode *ip; 144 struct gfs2_inode *ip;
172 struct gfs2_glock *io_gl = NULL; 145 struct gfs2_glock *io_gl = NULL;
173 int error; 146 int error;
174 147
175 inode = gfs2_iget(sb, no_addr); 148 inode = gfs2_iget(sb, no_addr, non_block);
176 ip = GFS2_I(inode); 149 ip = GFS2_I(inode);
177 150
178 if (!inode) 151 if (!inode)
@@ -195,132 +168,29 @@ struct inode *gfs2_inode_lookup(struct super_block *sb,
195 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh); 168 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
196 if (unlikely(error)) 169 if (unlikely(error))
197 goto fail_iopen; 170 goto fail_iopen;
198 ip->i_iopen_gh.gh_gl->gl_object = ip;
199 171
172 ip->i_iopen_gh.gh_gl->gl_object = ip;
200 gfs2_glock_put(io_gl); 173 gfs2_glock_put(io_gl);
201 io_gl = NULL; 174 io_gl = NULL;
202 175
203 if ((type == DT_UNKNOWN) && (no_formal_ino == 0))
204 goto gfs2_nfsbypass;
205
206 inode->i_mode = DT2IF(type);
207
208 /*
209 * We must read the inode in order to work out its type in
210 * this case. Note that this doesn't happen often as we normally
211 * know the type beforehand. This code path only occurs during
212 * unlinked inode recovery (where it is safe to do this glock,
213 * which is not true in the general case).
214 */
215 if (type == DT_UNKNOWN) { 176 if (type == DT_UNKNOWN) {
216 struct gfs2_holder gh; 177 /* Inode glock must be locked already */
217 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 178 error = gfs2_inode_refresh(GFS2_I(inode));
218 if (unlikely(error)) 179 if (error)
219 goto fail_glock; 180 goto fail_refresh;
220 /* Inode is now uptodate */ 181 } else {
221 gfs2_glock_dq_uninit(&gh); 182 inode->i_mode = DT2IF(type);
222 } 183 }
223 184
224 gfs2_set_iop(inode); 185 gfs2_set_iop(inode);
186 unlock_new_inode(inode);
225 } 187 }
226 188
227gfs2_nfsbypass:
228 return inode; 189 return inode;
229fail_glock:
230 gfs2_glock_dq(&ip->i_iopen_gh);
231fail_iopen:
232 if (io_gl)
233 gfs2_glock_put(io_gl);
234fail_put:
235 if (inode->i_state & I_NEW)
236 ip->i_gl->gl_object = NULL;
237 gfs2_glock_put(ip->i_gl);
238fail:
239 if (inode->i_state & I_NEW)
240 iget_failed(inode);
241 else
242 iput(inode);
243 return ERR_PTR(error);
244}
245
246/**
247 * gfs2_process_unlinked_inode - Lookup an unlinked inode for reclamation
248 * and try to reclaim it by doing iput.
249 *
250 * This function assumes no rgrp locks are currently held.
251 *
252 * @sb: The super block
253 * no_addr: The inode number
254 *
255 */
256
257void gfs2_process_unlinked_inode(struct super_block *sb, u64 no_addr)
258{
259 struct gfs2_sbd *sdp;
260 struct gfs2_inode *ip;
261 struct gfs2_glock *io_gl = NULL;
262 int error;
263 struct gfs2_holder gh;
264 struct inode *inode;
265
266 inode = gfs2_iget_skip(sb, no_addr);
267
268 if (!inode)
269 return;
270
271 /* If it's not a new inode, someone's using it, so leave it alone. */
272 if (!(inode->i_state & I_NEW)) {
273 iput(inode);
274 return;
275 }
276
277 ip = GFS2_I(inode);
278 sdp = GFS2_SB(inode);
279 ip->i_no_formal_ino = -1;
280
281 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
282 if (unlikely(error))
283 goto fail;
284 ip->i_gl->gl_object = ip;
285
286 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
287 if (unlikely(error))
288 goto fail_put;
289
290 set_bit(GIF_INVALID, &ip->i_flags);
291 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, LM_FLAG_TRY | GL_EXACT,
292 &ip->i_iopen_gh);
293 if (unlikely(error))
294 goto fail_iopen;
295
296 ip->i_iopen_gh.gh_gl->gl_object = ip;
297 gfs2_glock_put(io_gl);
298 io_gl = NULL;
299
300 inode->i_mode = DT2IF(DT_UNKNOWN);
301
302 /*
303 * We must read the inode in order to work out its type in
304 * this case. Note that this doesn't happen often as we normally
305 * know the type beforehand. This code path only occurs during
306 * unlinked inode recovery (where it is safe to do this glock,
307 * which is not true in the general case).
308 */
309 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, LM_FLAG_TRY,
310 &gh);
311 if (unlikely(error))
312 goto fail_glock;
313
314 /* Inode is now uptodate */
315 gfs2_glock_dq_uninit(&gh);
316 gfs2_set_iop(inode);
317
318 /* The iput will cause it to be deleted. */
319 iput(inode);
320 return;
321 190
322fail_glock: 191fail_refresh:
323 gfs2_glock_dq(&ip->i_iopen_gh); 192 ip->i_iopen_gh.gh_gl->gl_object = NULL;
193 gfs2_glock_dq_uninit(&ip->i_iopen_gh);
324fail_iopen: 194fail_iopen:
325 if (io_gl) 195 if (io_gl)
326 gfs2_glock_put(io_gl); 196 gfs2_glock_put(io_gl);
@@ -329,208 +199,53 @@ fail_put:
329 gfs2_glock_put(ip->i_gl); 199 gfs2_glock_put(ip->i_gl);
330fail: 200fail:
331 iget_failed(inode); 201 iget_failed(inode);
332 return; 202 return ERR_PTR(error);
333}
334
335static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
336{
337 const struct gfs2_dinode *str = buf;
338 struct timespec atime;
339 u16 height, depth;
340
341 if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
342 goto corrupt;
343 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
344 ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
345 ip->i_inode.i_rdev = 0;
346 switch (ip->i_inode.i_mode & S_IFMT) {
347 case S_IFBLK:
348 case S_IFCHR:
349 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
350 be32_to_cpu(str->di_minor));
351 break;
352 };
353
354 ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
355 ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
356 /*
357 * We will need to review setting the nlink count here in the
358 * light of the forthcoming ro bind mount work. This is a reminder
359 * to do that.
360 */
361 ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
362 ip->i_disksize = be64_to_cpu(str->di_size);
363 i_size_write(&ip->i_inode, ip->i_disksize);
364 gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
365 atime.tv_sec = be64_to_cpu(str->di_atime);
366 atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
367 if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0)
368 ip->i_inode.i_atime = atime;
369 ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
370 ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
371 ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
372 ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
373
374 ip->i_goal = be64_to_cpu(str->di_goal_meta);
375 ip->i_generation = be64_to_cpu(str->di_generation);
376
377 ip->i_diskflags = be32_to_cpu(str->di_flags);
378 gfs2_set_inode_flags(&ip->i_inode);
379 height = be16_to_cpu(str->di_height);
380 if (unlikely(height > GFS2_MAX_META_HEIGHT))
381 goto corrupt;
382 ip->i_height = (u8)height;
383
384 depth = be16_to_cpu(str->di_depth);
385 if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
386 goto corrupt;
387 ip->i_depth = (u8)depth;
388 ip->i_entries = be32_to_cpu(str->di_entries);
389
390 ip->i_eattr = be64_to_cpu(str->di_eattr);
391 if (S_ISREG(ip->i_inode.i_mode))
392 gfs2_set_aops(&ip->i_inode);
393
394 return 0;
395corrupt:
396 if (gfs2_consist_inode(ip))
397 gfs2_dinode_print(ip);
398 return -EIO;
399}
400
401/**
402 * gfs2_inode_refresh - Refresh the incore copy of the dinode
403 * @ip: The GFS2 inode
404 *
405 * Returns: errno
406 */
407
408int gfs2_inode_refresh(struct gfs2_inode *ip)
409{
410 struct buffer_head *dibh;
411 int error;
412
413 error = gfs2_meta_inode_buffer(ip, &dibh);
414 if (error)
415 return error;
416
417 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
418 brelse(dibh);
419 return -EIO;
420 }
421
422 error = gfs2_dinode_in(ip, dibh->b_data);
423 brelse(dibh);
424 clear_bit(GIF_INVALID, &ip->i_flags);
425
426 return error;
427} 203}
428 204
429int gfs2_dinode_dealloc(struct gfs2_inode *ip) 205struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
206 u64 *no_formal_ino, unsigned int blktype)
430{ 207{
431 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 208 struct super_block *sb = sdp->sd_vfs;
432 struct gfs2_alloc *al; 209 struct gfs2_holder i_gh;
433 struct gfs2_rgrpd *rgd; 210 struct inode *inode = NULL;
434 int error; 211 int error;
435 212
436 if (gfs2_get_inode_blocks(&ip->i_inode) != 1) { 213 /* Must not read in block until block type is verified */
437 if (gfs2_consist_inode(ip)) 214 error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
438 gfs2_dinode_print(ip); 215 LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
439 return -EIO;
440 }
441
442 al = gfs2_alloc_get(ip);
443 if (!al)
444 return -ENOMEM;
445
446 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
447 if (error)
448 goto out;
449
450 error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
451 if (error)
452 goto out_qs;
453
454 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
455 if (!rgd) {
456 gfs2_consist_inode(ip);
457 error = -EIO;
458 goto out_rindex_relse;
459 }
460
461 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
462 &al->al_rgd_gh);
463 if (error) 216 if (error)
464 goto out_rindex_relse; 217 return ERR_PTR(error);
465 218
466 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1); 219 error = gfs2_check_blk_type(sdp, no_addr, blktype);
467 if (error) 220 if (error)
468 goto out_rg_gunlock; 221 goto fail;
469
470 set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
471 set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags);
472
473 gfs2_free_di(rgd, ip);
474
475 gfs2_trans_end(sdp);
476 222
477out_rg_gunlock: 223 inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
478 gfs2_glock_dq_uninit(&al->al_rgd_gh); 224 if (IS_ERR(inode))
479out_rindex_relse: 225 goto fail;
480 gfs2_glock_dq_uninit(&al->al_ri_gh);
481out_qs:
482 gfs2_quota_unhold(ip);
483out:
484 gfs2_alloc_put(ip);
485 return error;
486}
487 226
488/** 227 /* Two extra checks for NFS only */
489 * gfs2_change_nlink - Change nlink count on inode 228 if (no_formal_ino) {
490 * @ip: The GFS2 inode 229 error = -ESTALE;
491 * @diff: The change in the nlink count required 230 if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
492 * 231 goto fail_iput;
493 * Returns: errno
494 */
495int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
496{
497 struct buffer_head *dibh;
498 u32 nlink;
499 int error;
500 232
501 BUG_ON(diff != 1 && diff != -1); 233 error = -EIO;
502 nlink = ip->i_inode.i_nlink + diff; 234 if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
235 goto fail_iput;
503 236
504 /* If we are reducing the nlink count, but the new value ends up being 237 error = 0;
505 bigger than the old one, we must have underflowed. */
506 if (diff < 0 && nlink > ip->i_inode.i_nlink) {
507 if (gfs2_consist_inode(ip))
508 gfs2_dinode_print(ip);
509 return -EIO;
510 } 238 }
511 239
512 error = gfs2_meta_inode_buffer(ip, &dibh); 240fail:
513 if (error) 241 gfs2_glock_dq_uninit(&i_gh);
514 return error; 242 return error ? ERR_PTR(error) : inode;
515 243fail_iput:
516 if (diff > 0) 244 iput(inode);
517 inc_nlink(&ip->i_inode); 245 goto fail;
518 else
519 drop_nlink(&ip->i_inode);
520
521 ip->i_inode.i_ctime = CURRENT_TIME;
522
523 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
524 gfs2_dinode_out(ip, dibh->b_data);
525 brelse(dibh);
526 mark_inode_dirty(&ip->i_inode);
527
528 if (ip->i_inode.i_nlink == 0)
529 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
530
531 return error;
532} 246}
533 247
248
534struct inode *gfs2_lookup_simple(struct inode *dip, const char *name) 249struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
535{ 250{
536 struct qstr qstr; 251 struct qstr qstr;
@@ -592,7 +307,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
592 } 307 }
593 308
594 if (!is_root) { 309 if (!is_root) {
595 error = gfs2_permission(dir, MAY_EXEC); 310 error = gfs2_permission(dir, MAY_EXEC, 0);
596 if (error) 311 if (error)
597 goto out; 312 goto out;
598 } 313 }
@@ -622,13 +337,13 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
622{ 337{
623 int error; 338 int error;
624 339
625 error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC); 340 error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
626 if (error) 341 if (error)
627 return error; 342 return error;
628 343
629 /* Don't create entries in an unlinked directory */ 344 /* Don't create entries in an unlinked directory */
630 if (!dip->i_inode.i_nlink) 345 if (!dip->i_inode.i_nlink)
631 return -EPERM; 346 return -ENOENT;
632 347
633 error = gfs2_dir_check(&dip->i_inode, name, NULL); 348 error = gfs2_dir_check(&dip->i_inode, name, NULL);
634 switch (error) { 349 switch (error) {
@@ -698,21 +413,44 @@ out:
698 return error; 413 return error;
699} 414}
700 415
416static void gfs2_init_dir(struct buffer_head *dibh,
417 const struct gfs2_inode *parent)
418{
419 struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
420 struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
421
422 gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
423 dent->de_inum = di->di_num; /* already GFS2 endian */
424 dent->de_type = cpu_to_be16(DT_DIR);
425
426 dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
427 gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
428 gfs2_inum_out(parent, dent);
429 dent->de_type = cpu_to_be16(DT_DIR);
430
431}
432
701/** 433/**
702 * init_dinode - Fill in a new dinode structure 434 * init_dinode - Fill in a new dinode structure
703 * @dip: the directory this inode is being created in 435 * @dip: The directory this inode is being created in
704 * @gl: The glock covering the new inode 436 * @gl: The glock covering the new inode
705 * @inum: the inode number 437 * @inum: The inode number
706 * @mode: the file permissions 438 * @mode: The file permissions
707 * @uid: 439 * @uid: The uid of the new inode
708 * @gid: 440 * @gid: The gid of the new inode
441 * @generation: The generation number of the new inode
442 * @dev: The device number (if a device node)
443 * @symname: The symlink destination (if a symlink)
444 * @size: The inode size (ignored for directories)
445 * @bhp: The buffer head (returned to caller)
709 * 446 *
710 */ 447 */
711 448
712static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 449static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
713 const struct gfs2_inum_host *inum, unsigned int mode, 450 const struct gfs2_inum_host *inum, unsigned int mode,
714 unsigned int uid, unsigned int gid, 451 unsigned int uid, unsigned int gid,
715 const u64 *generation, dev_t dev, struct buffer_head **bhp) 452 const u64 *generation, dev_t dev, const char *symname,
453 unsigned size, struct buffer_head **bhp)
716{ 454{
717 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 455 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
718 struct gfs2_dinode *di; 456 struct gfs2_dinode *di;
@@ -731,7 +469,7 @@ static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
731 di->di_uid = cpu_to_be32(uid); 469 di->di_uid = cpu_to_be32(uid);
732 di->di_gid = cpu_to_be32(gid); 470 di->di_gid = cpu_to_be32(gid);
733 di->di_nlink = 0; 471 di->di_nlink = 0;
734 di->di_size = 0; 472 di->di_size = cpu_to_be64(size);
735 di->di_blocks = cpu_to_be64(1); 473 di->di_blocks = cpu_to_be64(1);
736 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec); 474 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
737 di->di_major = cpu_to_be32(MAJOR(dev)); 475 di->di_major = cpu_to_be32(MAJOR(dev));
@@ -739,16 +477,6 @@ static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
739 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr); 477 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
740 di->di_generation = cpu_to_be64(*generation); 478 di->di_generation = cpu_to_be64(*generation);
741 di->di_flags = 0; 479 di->di_flags = 0;
742
743 if (S_ISREG(mode)) {
744 if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
745 gfs2_tune_get(sdp, gt_new_files_jdata))
746 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
747 } else if (S_ISDIR(mode)) {
748 di->di_flags |= cpu_to_be32(dip->i_diskflags &
749 GFS2_DIF_INHERIT_JDATA);
750 }
751
752 di->__pad1 = 0; 480 di->__pad1 = 0;
753 di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0); 481 di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
754 di->di_height = 0; 482 di->di_height = 0;
@@ -762,7 +490,26 @@ static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
762 di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec); 490 di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
763 di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec); 491 di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
764 memset(&di->di_reserved, 0, sizeof(di->di_reserved)); 492 memset(&di->di_reserved, 0, sizeof(di->di_reserved));
765 493
494 switch(mode & S_IFMT) {
495 case S_IFREG:
496 if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
497 gfs2_tune_get(sdp, gt_new_files_jdata))
498 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
499 break;
500 case S_IFDIR:
501 di->di_flags |= cpu_to_be32(dip->i_diskflags &
502 GFS2_DIF_INHERIT_JDATA);
503 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
504 di->di_size = cpu_to_be64(sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode));
505 di->di_entries = cpu_to_be32(2);
506 gfs2_init_dir(dibh, dip);
507 break;
508 case S_IFLNK:
509 memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, size);
510 break;
511 }
512
766 set_buffer_uptodate(dibh); 513 set_buffer_uptodate(dibh);
767 514
768 *bhp = dibh; 515 *bhp = dibh;
@@ -770,7 +517,8 @@ static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
770 517
771static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 518static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
772 unsigned int mode, const struct gfs2_inum_host *inum, 519 unsigned int mode, const struct gfs2_inum_host *inum,
773 const u64 *generation, dev_t dev, struct buffer_head **bhp) 520 const u64 *generation, dev_t dev, const char *symname,
521 unsigned int size, struct buffer_head **bhp)
774{ 522{
775 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 523 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
776 unsigned int uid, gid; 524 unsigned int uid, gid;
@@ -792,7 +540,7 @@ static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
792 if (error) 540 if (error)
793 goto out_quota; 541 goto out_quota;
794 542
795 init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp); 543 init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, symname, size, bhp);
796 gfs2_quota_change(dip, +1, uid, gid); 544 gfs2_quota_change(dip, +1, uid, gid);
797 gfs2_trans_end(sdp); 545 gfs2_trans_end(sdp);
798 546
@@ -846,14 +594,16 @@ static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
846 goto fail_quota_locks; 594 goto fail_quota_locks;
847 } 595 }
848 596
849 error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode)); 597 error = gfs2_dir_add(&dip->i_inode, name, ip);
850 if (error) 598 if (error)
851 goto fail_end_trans; 599 goto fail_end_trans;
852 600
853 error = gfs2_meta_inode_buffer(ip, &dibh); 601 error = gfs2_meta_inode_buffer(ip, &dibh);
854 if (error) 602 if (error)
855 goto fail_end_trans; 603 goto fail_end_trans;
856 ip->i_inode.i_nlink = 1; 604 inc_nlink(&ip->i_inode);
605 if (S_ISDIR(ip->i_inode.i_mode))
606 inc_nlink(&ip->i_inode);
857 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 607 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
858 gfs2_dinode_out(ip, dibh->b_data); 608 gfs2_dinode_out(ip, dibh->b_data);
859 brelse(dibh); 609 brelse(dibh);
@@ -874,14 +624,15 @@ fail:
874 return error; 624 return error;
875} 625}
876 626
877static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip) 627static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
628 const struct qstr *qstr)
878{ 629{
879 int err; 630 int err;
880 size_t len; 631 size_t len;
881 void *value; 632 void *value;
882 char *name; 633 char *name;
883 634
884 err = security_inode_init_security(&ip->i_inode, &dip->i_inode, 635 err = security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
885 &name, &value, &len); 636 &name, &value, &len);
886 637
887 if (err) { 638 if (err) {
@@ -899,27 +650,25 @@ static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
899} 650}
900 651
901/** 652/**
902 * gfs2_createi - Create a new inode 653 * gfs2_create_inode - Create a new inode
903 * @ghs: An array of two holders 654 * @dir: The parent directory
904 * @name: The name of the new file 655 * @dentry: The new dentry
905 * @mode: the permissions on the new inode 656 * @mode: The permissions on the new inode
906 * 657 * @dev: For device nodes, this is the device number
907 * @ghs[0] is an initialized holder for the directory 658 * @symname: For symlinks, this is the link destination
908 * @ghs[1] is the holder for the inode lock 659 * @size: The initial size of the inode (ignored for directories)
909 *
910 * If the return value is not NULL, the glocks on both the directory and the new
911 * file are held. A transaction has been started and an inplace reservation
912 * is held, as well.
913 * 660 *
914 * Returns: An inode 661 * Returns: 0 on success, or error code
915 */ 662 */
916 663
917struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name, 664static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
918 unsigned int mode, dev_t dev) 665 unsigned int mode, dev_t dev, const char *symname,
666 unsigned int size)
919{ 667{
668 const struct qstr *name = &dentry->d_name;
669 struct gfs2_holder ghs[2];
920 struct inode *inode = NULL; 670 struct inode *inode = NULL;
921 struct gfs2_inode *dip = ghs->gh_gl->gl_object; 671 struct gfs2_inode *dip = GFS2_I(dir);
922 struct inode *dir = &dip->i_inode;
923 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 672 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
924 struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 }; 673 struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
925 int error; 674 int error;
@@ -927,10 +676,9 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
927 struct buffer_head *bh = NULL; 676 struct buffer_head *bh = NULL;
928 677
929 if (!name->len || name->len > GFS2_FNAMESIZE) 678 if (!name->len || name->len > GFS2_FNAMESIZE)
930 return ERR_PTR(-ENAMETOOLONG); 679 return -ENAMETOOLONG;
931 680
932 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs); 681 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
933 error = gfs2_glock_nq(ghs);
934 if (error) 682 if (error)
935 goto fail; 683 goto fail;
936 684
@@ -948,12 +696,12 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
948 if (error) 696 if (error)
949 goto fail_gunlock; 697 goto fail_gunlock;
950 698
951 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh); 699 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, symname, size, &bh);
952 if (error) 700 if (error)
953 goto fail_gunlock2; 701 goto fail_gunlock2;
954 702
955 inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr, 703 inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,
956 inum.no_formal_ino); 704 inum.no_formal_ino, 0);
957 if (IS_ERR(inode)) 705 if (IS_ERR(inode))
958 goto fail_gunlock2; 706 goto fail_gunlock2;
959 707
@@ -965,7 +713,7 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
965 if (error) 713 if (error)
966 goto fail_gunlock2; 714 goto fail_gunlock2;
967 715
968 error = gfs2_security_init(dip, GFS2_I(inode)); 716 error = gfs2_security_init(dip, GFS2_I(inode), name);
969 if (error) 717 if (error)
970 goto fail_gunlock2; 718 goto fail_gunlock2;
971 719
@@ -975,41 +723,866 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
975 723
976 if (bh) 724 if (bh)
977 brelse(bh); 725 brelse(bh);
978 return inode; 726
727 gfs2_trans_end(sdp);
728 if (dip->i_alloc->al_rgd)
729 gfs2_inplace_release(dip);
730 gfs2_quota_unlock(dip);
731 gfs2_alloc_put(dip);
732 gfs2_glock_dq_uninit_m(2, ghs);
733 mark_inode_dirty(inode);
734 d_instantiate(dentry, inode);
735 return 0;
979 736
980fail_gunlock2: 737fail_gunlock2:
981 gfs2_glock_dq_uninit(ghs + 1); 738 gfs2_glock_dq_uninit(ghs + 1);
982 if (inode && !IS_ERR(inode)) 739 if (inode && !IS_ERR(inode))
983 iput(inode); 740 iput(inode);
984fail_gunlock: 741fail_gunlock:
985 gfs2_glock_dq(ghs); 742 gfs2_glock_dq_uninit(ghs);
986fail: 743fail:
987 if (bh) 744 if (bh)
988 brelse(bh); 745 brelse(bh);
989 return ERR_PTR(error); 746 return error;
990} 747}
991 748
992static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 749/**
750 * gfs2_create - Create a file
751 * @dir: The directory in which to create the file
752 * @dentry: The dentry of the new file
753 * @mode: The mode of the new file
754 *
755 * Returns: errno
756 */
757
758static int gfs2_create(struct inode *dir, struct dentry *dentry,
759 int mode, struct nameidata *nd)
993{ 760{
994 struct inode *inode = &ip->i_inode; 761 struct inode *inode;
762 int ret;
763
764 for (;;) {
765 ret = gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0);
766 if (ret != -EEXIST || (nd && (nd->flags & LOOKUP_EXCL)))
767 return ret;
768
769 inode = gfs2_lookupi(dir, &dentry->d_name, 0);
770 if (inode) {
771 if (!IS_ERR(inode))
772 break;
773 return PTR_ERR(inode);
774 }
775 }
776
777 d_instantiate(dentry, inode);
778 return 0;
779}
780
781/**
782 * gfs2_lookup - Look up a filename in a directory and return its inode
783 * @dir: The directory inode
784 * @dentry: The dentry of the new inode
785 * @nd: passed from Linux VFS, ignored by us
786 *
787 * Called by the VFS layer. Lock dir and call gfs2_lookupi()
788 *
789 * Returns: errno
790 */
791
792static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
793 struct nameidata *nd)
794{
795 struct inode *inode = NULL;
796
797 inode = gfs2_lookupi(dir, &dentry->d_name, 0);
798 if (inode && IS_ERR(inode))
799 return ERR_CAST(inode);
800
801 if (inode) {
802 struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
803 struct gfs2_holder gh;
804 int error;
805 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
806 if (error) {
807 iput(inode);
808 return ERR_PTR(error);
809 }
810 gfs2_glock_dq_uninit(&gh);
811 return d_splice_alias(inode, dentry);
812 }
813 d_add(dentry, inode);
814
815 return NULL;
816}
817
818/**
819 * gfs2_link - Link to a file
820 * @old_dentry: The inode to link
821 * @dir: Add link to this directory
822 * @dentry: The name of the link
823 *
824 * Link the inode in "old_dentry" into the directory "dir" with the
825 * name in "dentry".
826 *
827 * Returns: errno
828 */
829
830static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
831 struct dentry *dentry)
832{
833 struct gfs2_inode *dip = GFS2_I(dir);
834 struct gfs2_sbd *sdp = GFS2_SB(dir);
835 struct inode *inode = old_dentry->d_inode;
836 struct gfs2_inode *ip = GFS2_I(inode);
837 struct gfs2_holder ghs[2];
995 struct buffer_head *dibh; 838 struct buffer_head *dibh;
839 int alloc_required;
996 int error; 840 int error;
997 841
842 if (S_ISDIR(inode->i_mode))
843 return -EPERM;
844
845 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
846 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
847
848 error = gfs2_glock_nq(ghs); /* parent */
849 if (error)
850 goto out_parent;
851
852 error = gfs2_glock_nq(ghs + 1); /* child */
853 if (error)
854 goto out_child;
855
856 error = -ENOENT;
857 if (inode->i_nlink == 0)
858 goto out_gunlock;
859
860 error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC, 0);
861 if (error)
862 goto out_gunlock;
863
864 error = gfs2_dir_check(dir, &dentry->d_name, NULL);
865 switch (error) {
866 case -ENOENT:
867 break;
868 case 0:
869 error = -EEXIST;
870 default:
871 goto out_gunlock;
872 }
873
874 error = -EINVAL;
875 if (!dip->i_inode.i_nlink)
876 goto out_gunlock;
877 error = -EFBIG;
878 if (dip->i_entries == (u32)-1)
879 goto out_gunlock;
880 error = -EPERM;
881 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
882 goto out_gunlock;
883 error = -EINVAL;
884 if (!ip->i_inode.i_nlink)
885 goto out_gunlock;
886 error = -EMLINK;
887 if (ip->i_inode.i_nlink == (u32)-1)
888 goto out_gunlock;
889
890 alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
891 if (error < 0)
892 goto out_gunlock;
893 error = 0;
894
895 if (alloc_required) {
896 struct gfs2_alloc *al = gfs2_alloc_get(dip);
897 if (!al) {
898 error = -ENOMEM;
899 goto out_gunlock;
900 }
901
902 error = gfs2_quota_lock_check(dip);
903 if (error)
904 goto out_alloc;
905
906 al->al_requested = sdp->sd_max_dirres;
907
908 error = gfs2_inplace_reserve(dip);
909 if (error)
910 goto out_gunlock_q;
911
912 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
913 gfs2_rg_blocks(al) +
914 2 * RES_DINODE + RES_STATFS +
915 RES_QUOTA, 0);
916 if (error)
917 goto out_ipres;
918 } else {
919 error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
920 if (error)
921 goto out_ipres;
922 }
923
998 error = gfs2_meta_inode_buffer(ip, &dibh); 924 error = gfs2_meta_inode_buffer(ip, &dibh);
999 if (error) 925 if (error)
926 goto out_end_trans;
927
928 error = gfs2_dir_add(dir, &dentry->d_name, ip);
929 if (error)
930 goto out_brelse;
931
932 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
933 inc_nlink(&ip->i_inode);
934 ip->i_inode.i_ctime = CURRENT_TIME;
935 gfs2_dinode_out(ip, dibh->b_data);
936 mark_inode_dirty(&ip->i_inode);
937
938out_brelse:
939 brelse(dibh);
940out_end_trans:
941 gfs2_trans_end(sdp);
942out_ipres:
943 if (alloc_required)
944 gfs2_inplace_release(dip);
945out_gunlock_q:
946 if (alloc_required)
947 gfs2_quota_unlock(dip);
948out_alloc:
949 if (alloc_required)
950 gfs2_alloc_put(dip);
951out_gunlock:
952 gfs2_glock_dq(ghs + 1);
953out_child:
954 gfs2_glock_dq(ghs);
955out_parent:
956 gfs2_holder_uninit(ghs);
957 gfs2_holder_uninit(ghs + 1);
958 if (!error) {
959 ihold(inode);
960 d_instantiate(dentry, inode);
961 mark_inode_dirty(inode);
962 }
963 return error;
964}
965
966/*
967 * gfs2_unlink_ok - check to see that a inode is still in a directory
968 * @dip: the directory
969 * @name: the name of the file
970 * @ip: the inode
971 *
972 * Assumes that the lock on (at least) @dip is held.
973 *
974 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
975 */
976
977static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
978 const struct gfs2_inode *ip)
979{
980 int error;
981
982 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
983 return -EPERM;
984
985 if ((dip->i_inode.i_mode & S_ISVTX) &&
986 dip->i_inode.i_uid != current_fsuid() &&
987 ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
988 return -EPERM;
989
990 if (IS_APPEND(&dip->i_inode))
991 return -EPERM;
992
993 error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
994 if (error)
995 return error;
996
997 error = gfs2_dir_check(&dip->i_inode, name, ip);
998 if (error)
1000 return error; 999 return error;
1001 1000
1002 if ((attr->ia_valid & ATTR_SIZE) && 1001 return 0;
1003 attr->ia_size != i_size_read(inode)) { 1002}
1004 error = vmtruncate(inode, attr->ia_size); 1003
1004/**
1005 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
1006 * @dip: The parent directory
1007 * @name: The name of the entry in the parent directory
1008 * @bh: The inode buffer for the inode to be removed
1009 * @inode: The inode to be removed
1010 *
1011 * Called with all the locks and in a transaction. This will only be
1012 * called for a directory after it has been checked to ensure it is empty.
1013 *
1014 * Returns: 0 on success, or an error
1015 */
1016
1017static int gfs2_unlink_inode(struct gfs2_inode *dip,
1018 const struct dentry *dentry,
1019 struct buffer_head *bh)
1020{
1021 struct inode *inode = dentry->d_inode;
1022 struct gfs2_inode *ip = GFS2_I(inode);
1023 int error;
1024
1025 error = gfs2_dir_del(dip, dentry);
1026 if (error)
1027 return error;
1028
1029 ip->i_entries = 0;
1030 inode->i_ctime = CURRENT_TIME;
1031 if (S_ISDIR(inode->i_mode))
1032 clear_nlink(inode);
1033 else
1034 drop_nlink(inode);
1035 gfs2_trans_add_bh(ip->i_gl, bh, 1);
1036 gfs2_dinode_out(ip, bh->b_data);
1037 mark_inode_dirty(inode);
1038 if (inode->i_nlink == 0)
1039 gfs2_unlink_di(inode);
1040 return 0;
1041}
1042
1043
1044/**
1045 * gfs2_unlink - Unlink an inode (this does rmdir as well)
1046 * @dir: The inode of the directory containing the inode to unlink
1047 * @dentry: The file itself
1048 *
1049 * This routine uses the type of the inode as a flag to figure out
1050 * whether this is an unlink or an rmdir.
1051 *
1052 * Returns: errno
1053 */
1054
1055static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1056{
1057 struct gfs2_inode *dip = GFS2_I(dir);
1058 struct gfs2_sbd *sdp = GFS2_SB(dir);
1059 struct inode *inode = dentry->d_inode;
1060 struct gfs2_inode *ip = GFS2_I(inode);
1061 struct buffer_head *bh;
1062 struct gfs2_holder ghs[3];
1063 struct gfs2_rgrpd *rgd;
1064 struct gfs2_holder ri_gh;
1065 int error;
1066
1067 error = gfs2_rindex_hold(sdp, &ri_gh);
1068 if (error)
1069 return error;
1070
1071 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1072 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
1073
1074 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
1075 gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
1076
1077
1078 error = gfs2_glock_nq(ghs); /* parent */
1079 if (error)
1080 goto out_parent;
1081
1082 error = gfs2_glock_nq(ghs + 1); /* child */
1083 if (error)
1084 goto out_child;
1085
1086 error = -ENOENT;
1087 if (inode->i_nlink == 0)
1088 goto out_rgrp;
1089
1090 if (S_ISDIR(inode->i_mode)) {
1091 error = -ENOTEMPTY;
1092 if (ip->i_entries > 2 || inode->i_nlink > 2)
1093 goto out_rgrp;
1094 }
1095
1096 error = gfs2_glock_nq(ghs + 2); /* rgrp */
1097 if (error)
1098 goto out_rgrp;
1099
1100 error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1101 if (error)
1102 goto out_gunlock;
1103
1104 error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1105 if (error)
1106 goto out_gunlock;
1107
1108 error = gfs2_meta_inode_buffer(ip, &bh);
1109 if (error)
1110 goto out_end_trans;
1111
1112 error = gfs2_unlink_inode(dip, dentry, bh);
1113 brelse(bh);
1114
1115out_end_trans:
1116 gfs2_trans_end(sdp);
1117out_gunlock:
1118 gfs2_glock_dq(ghs + 2);
1119out_rgrp:
1120 gfs2_holder_uninit(ghs + 2);
1121 gfs2_glock_dq(ghs + 1);
1122out_child:
1123 gfs2_holder_uninit(ghs + 1);
1124 gfs2_glock_dq(ghs);
1125out_parent:
1126 gfs2_holder_uninit(ghs);
1127 gfs2_glock_dq_uninit(&ri_gh);
1128 return error;
1129}
1130
1131/**
1132 * gfs2_symlink - Create a symlink
1133 * @dir: The directory to create the symlink in
1134 * @dentry: The dentry to put the symlink in
1135 * @symname: The thing which the link points to
1136 *
1137 * Returns: errno
1138 */
1139
1140static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
1141 const char *symname)
1142{
1143 struct gfs2_sbd *sdp = GFS2_SB(dir);
1144 unsigned int size;
1145
1146 size = strlen(symname);
1147 if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
1148 return -ENAMETOOLONG;
1149
1150 return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size);
1151}
1152
1153/**
1154 * gfs2_mkdir - Make a directory
1155 * @dir: The parent directory of the new one
1156 * @dentry: The dentry of the new directory
1157 * @mode: The mode of the new directory
1158 *
1159 * Returns: errno
1160 */
1161
1162static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1163{
1164 return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, 0);
1165}
1166
1167/**
1168 * gfs2_mknod - Make a special file
1169 * @dir: The directory in which the special file will reside
1170 * @dentry: The dentry of the special file
1171 * @mode: The mode of the special file
1172 * @dev: The device specification of the special file
1173 *
1174 */
1175
1176static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
1177 dev_t dev)
1178{
1179 return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0);
1180}
1181
1182/*
1183 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1184 * @this: move this
1185 * @to: to here
1186 *
1187 * Follow @to back to the root and make sure we don't encounter @this
1188 * Assumes we already hold the rename lock.
1189 *
1190 * Returns: errno
1191 */
1192
1193static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1194{
1195 struct inode *dir = &to->i_inode;
1196 struct super_block *sb = dir->i_sb;
1197 struct inode *tmp;
1198 int error = 0;
1199
1200 igrab(dir);
1201
1202 for (;;) {
1203 if (dir == &this->i_inode) {
1204 error = -EINVAL;
1205 break;
1206 }
1207 if (dir == sb->s_root->d_inode) {
1208 error = 0;
1209 break;
1210 }
1211
1212 tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1213 if (IS_ERR(tmp)) {
1214 error = PTR_ERR(tmp);
1215 break;
1216 }
1217
1218 iput(dir);
1219 dir = tmp;
1220 }
1221
1222 iput(dir);
1223
1224 return error;
1225}
1226
1227/**
1228 * gfs2_rename - Rename a file
1229 * @odir: Parent directory of old file name
1230 * @odentry: The old dentry of the file
1231 * @ndir: Parent directory of new file name
1232 * @ndentry: The new dentry of the file
1233 *
1234 * Returns: errno
1235 */
1236
1237static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1238 struct inode *ndir, struct dentry *ndentry)
1239{
1240 struct gfs2_inode *odip = GFS2_I(odir);
1241 struct gfs2_inode *ndip = GFS2_I(ndir);
1242 struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
1243 struct gfs2_inode *nip = NULL;
1244 struct gfs2_sbd *sdp = GFS2_SB(odir);
1245 struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, }, ri_gh;
1246 struct gfs2_rgrpd *nrgd;
1247 unsigned int num_gh;
1248 int dir_rename = 0;
1249 int alloc_required = 0;
1250 unsigned int x;
1251 int error;
1252
1253 if (ndentry->d_inode) {
1254 nip = GFS2_I(ndentry->d_inode);
1255 if (ip == nip)
1256 return 0;
1257 }
1258
1259 error = gfs2_rindex_hold(sdp, &ri_gh);
1260 if (error)
1261 return error;
1262
1263 if (odip != ndip) {
1264 error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1265 0, &r_gh);
1266 if (error)
1267 goto out;
1268
1269 if (S_ISDIR(ip->i_inode.i_mode)) {
1270 dir_rename = 1;
1271 /* don't move a dirctory into it's subdir */
1272 error = gfs2_ok_to_move(ip, ndip);
1273 if (error)
1274 goto out_gunlock_r;
1275 }
1276 }
1277
1278 num_gh = 1;
1279 gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1280 if (odip != ndip) {
1281 gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1282 num_gh++;
1283 }
1284 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1285 num_gh++;
1286
1287 if (nip) {
1288 gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1289 num_gh++;
1290 /* grab the resource lock for unlink flag twiddling
1291 * this is the case of the target file already existing
1292 * so we unlink before doing the rename
1293 */
1294 nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr);
1295 if (nrgd)
1296 gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1297 }
1298
1299 for (x = 0; x < num_gh; x++) {
1300 error = gfs2_glock_nq(ghs + x);
1301 if (error)
1302 goto out_gunlock;
1303 }
1304
1305 error = -ENOENT;
1306 if (ip->i_inode.i_nlink == 0)
1307 goto out_gunlock;
1308
1309 /* Check out the old directory */
1310
1311 error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1312 if (error)
1313 goto out_gunlock;
1314
1315 /* Check out the new directory */
1316
1317 if (nip) {
1318 error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1319 if (error)
1320 goto out_gunlock;
1321
1322 if (nip->i_inode.i_nlink == 0) {
1323 error = -EAGAIN;
1324 goto out_gunlock;
1325 }
1326
1327 if (S_ISDIR(nip->i_inode.i_mode)) {
1328 if (nip->i_entries < 2) {
1329 gfs2_consist_inode(nip);
1330 error = -EIO;
1331 goto out_gunlock;
1332 }
1333 if (nip->i_entries > 2) {
1334 error = -ENOTEMPTY;
1335 goto out_gunlock;
1336 }
1337 }
1338 } else {
1339 error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC, 0);
1340 if (error)
1341 goto out_gunlock;
1342
1343 error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1344 switch (error) {
1345 case -ENOENT:
1346 error = 0;
1347 break;
1348 case 0:
1349 error = -EEXIST;
1350 default:
1351 goto out_gunlock;
1352 };
1353
1354 if (odip != ndip) {
1355 if (!ndip->i_inode.i_nlink) {
1356 error = -ENOENT;
1357 goto out_gunlock;
1358 }
1359 if (ndip->i_entries == (u32)-1) {
1360 error = -EFBIG;
1361 goto out_gunlock;
1362 }
1363 if (S_ISDIR(ip->i_inode.i_mode) &&
1364 ndip->i_inode.i_nlink == (u32)-1) {
1365 error = -EMLINK;
1366 goto out_gunlock;
1367 }
1368 }
1369 }
1370
1371 /* Check out the dir to be renamed */
1372
1373 if (dir_rename) {
1374 error = gfs2_permission(odentry->d_inode, MAY_WRITE, 0);
1375 if (error)
1376 goto out_gunlock;
1377 }
1378
1379 if (nip == NULL)
1380 alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
1381 error = alloc_required;
1382 if (error < 0)
1383 goto out_gunlock;
1384 error = 0;
1385
1386 if (alloc_required) {
1387 struct gfs2_alloc *al = gfs2_alloc_get(ndip);
1388 if (!al) {
1389 error = -ENOMEM;
1390 goto out_gunlock;
1391 }
1392
1393 error = gfs2_quota_lock_check(ndip);
1394 if (error)
1395 goto out_alloc;
1396
1397 al->al_requested = sdp->sd_max_dirres;
1398
1399 error = gfs2_inplace_reserve_ri(ndip);
1400 if (error)
1401 goto out_gunlock_q;
1402
1403 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
1404 gfs2_rg_blocks(al) +
1405 4 * RES_DINODE + 4 * RES_LEAF +
1406 RES_STATFS + RES_QUOTA + 4, 0);
1407 if (error)
1408 goto out_ipreserv;
1409 } else {
1410 error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1411 5 * RES_LEAF + 4, 0);
1412 if (error)
1413 goto out_gunlock;
1414 }
1415
1416 /* Remove the target file, if it exists */
1417
1418 if (nip) {
1419 struct buffer_head *bh;
1420 error = gfs2_meta_inode_buffer(nip, &bh);
1421 if (error)
1422 goto out_end_trans;
1423 error = gfs2_unlink_inode(ndip, ndentry, bh);
1424 brelse(bh);
1425 }
1426
1427 if (dir_rename) {
1428 error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1429 if (error)
1430 goto out_end_trans;
1431 } else {
1432 struct buffer_head *dibh;
1433 error = gfs2_meta_inode_buffer(ip, &dibh);
1434 if (error)
1435 goto out_end_trans;
1436 ip->i_inode.i_ctime = CURRENT_TIME;
1437 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1438 gfs2_dinode_out(ip, dibh->b_data);
1439 brelse(dibh);
1440 }
1441
1442 error = gfs2_dir_del(odip, odentry);
1443 if (error)
1444 goto out_end_trans;
1445
1446 error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
1447 if (error)
1448 goto out_end_trans;
1449
1450out_end_trans:
1451 gfs2_trans_end(sdp);
1452out_ipreserv:
1453 if (alloc_required)
1454 gfs2_inplace_release(ndip);
1455out_gunlock_q:
1456 if (alloc_required)
1457 gfs2_quota_unlock(ndip);
1458out_alloc:
1459 if (alloc_required)
1460 gfs2_alloc_put(ndip);
1461out_gunlock:
1462 while (x--) {
1463 gfs2_glock_dq(ghs + x);
1464 gfs2_holder_uninit(ghs + x);
1465 }
1466out_gunlock_r:
1467 if (r_gh.gh_gl)
1468 gfs2_glock_dq_uninit(&r_gh);
1469out:
1470 gfs2_glock_dq_uninit(&ri_gh);
1471 return error;
1472}
1473
1474/**
1475 * gfs2_follow_link - Follow a symbolic link
1476 * @dentry: The dentry of the link
1477 * @nd: Data that we pass to vfs_follow_link()
1478 *
1479 * This can handle symlinks of any size.
1480 *
1481 * Returns: 0 on success or error code
1482 */
1483
1484static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
1485{
1486 struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
1487 struct gfs2_holder i_gh;
1488 struct buffer_head *dibh;
1489 unsigned int size;
1490 char *buf;
1491 int error;
1492
1493 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1494 error = gfs2_glock_nq(&i_gh);
1495 if (error) {
1496 gfs2_holder_uninit(&i_gh);
1497 nd_set_link(nd, ERR_PTR(error));
1498 return NULL;
1499 }
1500
1501 size = (unsigned int)i_size_read(&ip->i_inode);
1502 if (size == 0) {
1503 gfs2_consist_inode(ip);
1504 buf = ERR_PTR(-EIO);
1505 goto out;
1506 }
1507
1508 error = gfs2_meta_inode_buffer(ip, &dibh);
1509 if (error) {
1510 buf = ERR_PTR(error);
1511 goto out;
1512 }
1513
1514 buf = kzalloc(size + 1, GFP_NOFS);
1515 if (!buf)
1516 buf = ERR_PTR(-ENOMEM);
1517 else
1518 memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1519 brelse(dibh);
1520out:
1521 gfs2_glock_dq_uninit(&i_gh);
1522 nd_set_link(nd, buf);
1523 return NULL;
1524}
1525
1526static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1527{
1528 char *s = nd_get_link(nd);
1529 if (!IS_ERR(s))
1530 kfree(s);
1531}
1532
1533/**
1534 * gfs2_permission -
1535 * @inode: The inode
1536 * @mask: The mask to be tested
1537 * @flags: Indicates whether this is an RCU path walk or not
1538 *
1539 * This may be called from the VFS directly, or from within GFS2 with the
1540 * inode locked, so we look to see if the glock is already locked and only
1541 * lock the glock if its not already been done.
1542 *
1543 * Returns: errno
1544 */
1545
1546int gfs2_permission(struct inode *inode, int mask, unsigned int flags)
1547{
1548 struct gfs2_inode *ip;
1549 struct gfs2_holder i_gh;
1550 int error;
1551 int unlock = 0;
1552
1553
1554 ip = GFS2_I(inode);
1555 if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1556 if (flags & IPERM_FLAG_RCU)
1557 return -ECHILD;
1558 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1005 if (error) 1559 if (error)
1006 return error; 1560 return error;
1561 unlock = 1;
1007 } 1562 }
1008 1563
1564 if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1565 error = -EACCES;
1566 else
1567 error = generic_permission(inode, mask, flags, gfs2_check_acl);
1568 if (unlock)
1569 gfs2_glock_dq_uninit(&i_gh);
1570
1571 return error;
1572}
1573
1574static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1575{
1576 struct inode *inode = &ip->i_inode;
1577 struct buffer_head *dibh;
1578 int error;
1579
1580 error = gfs2_meta_inode_buffer(ip, &dibh);
1581 if (error)
1582 return error;
1583
1009 setattr_copy(inode, attr); 1584 setattr_copy(inode, attr);
1010 mark_inode_dirty(inode); 1585 mark_inode_dirty(inode);
1011
1012 gfs2_assert_warn(GFS2_SB(inode), !error);
1013 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1586 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1014 gfs2_dinode_out(ip, dibh->b_data); 1587 gfs2_dinode_out(ip, dibh->b_data);
1015 brelse(dibh); 1588 brelse(dibh);
@@ -1021,8 +1594,6 @@ static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1021 * @ip: 1594 * @ip:
1022 * @attr: 1595 * @attr:
1023 * 1596 *
1024 * Called with a reference on the vnode.
1025 *
1026 * Returns: errno 1597 * Returns: errno
1027 */ 1598 */
1028 1599
@@ -1042,60 +1613,280 @@ int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1042 return error; 1613 return error;
1043} 1614}
1044 1615
1045void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf) 1616static int setattr_chown(struct inode *inode, struct iattr *attr)
1617{
1618 struct gfs2_inode *ip = GFS2_I(inode);
1619 struct gfs2_sbd *sdp = GFS2_SB(inode);
1620 u32 ouid, ogid, nuid, ngid;
1621 int error;
1622
1623 ouid = inode->i_uid;
1624 ogid = inode->i_gid;
1625 nuid = attr->ia_uid;
1626 ngid = attr->ia_gid;
1627
1628 if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
1629 ouid = nuid = NO_QUOTA_CHANGE;
1630 if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
1631 ogid = ngid = NO_QUOTA_CHANGE;
1632
1633 if (!gfs2_alloc_get(ip))
1634 return -ENOMEM;
1635
1636 error = gfs2_quota_lock(ip, nuid, ngid);
1637 if (error)
1638 goto out_alloc;
1639
1640 if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1641 error = gfs2_quota_check(ip, nuid, ngid);
1642 if (error)
1643 goto out_gunlock_q;
1644 }
1645
1646 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1647 if (error)
1648 goto out_gunlock_q;
1649
1650 error = gfs2_setattr_simple(ip, attr);
1651 if (error)
1652 goto out_end_trans;
1653
1654 if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1655 u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
1656 gfs2_quota_change(ip, -blocks, ouid, ogid);
1657 gfs2_quota_change(ip, blocks, nuid, ngid);
1658 }
1659
1660out_end_trans:
1661 gfs2_trans_end(sdp);
1662out_gunlock_q:
1663 gfs2_quota_unlock(ip);
1664out_alloc:
1665 gfs2_alloc_put(ip);
1666 return error;
1667}
1668
1669/**
1670 * gfs2_setattr - Change attributes on an inode
1671 * @dentry: The dentry which is changing
1672 * @attr: The structure describing the change
1673 *
1674 * The VFS layer wants to change one or more of an inodes attributes. Write
1675 * that change out to disk.
1676 *
1677 * Returns: errno
1678 */
1679
1680static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
1681{
1682 struct inode *inode = dentry->d_inode;
1683 struct gfs2_inode *ip = GFS2_I(inode);
1684 struct gfs2_holder i_gh;
1685 int error;
1686
1687 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1688 if (error)
1689 return error;
1690
1691 error = -EPERM;
1692 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1693 goto out;
1694
1695 error = inode_change_ok(inode, attr);
1696 if (error)
1697 goto out;
1698
1699 if (attr->ia_valid & ATTR_SIZE)
1700 error = gfs2_setattr_size(inode, attr->ia_size);
1701 else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1702 error = setattr_chown(inode, attr);
1703 else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
1704 error = gfs2_acl_chmod(ip, attr);
1705 else
1706 error = gfs2_setattr_simple(ip, attr);
1707
1708out:
1709 gfs2_glock_dq_uninit(&i_gh);
1710 if (!error)
1711 mark_inode_dirty(inode);
1712 return error;
1713}
1714
1715/**
1716 * gfs2_getattr - Read out an inode's attributes
1717 * @mnt: The vfsmount the inode is being accessed from
1718 * @dentry: The dentry to stat
1719 * @stat: The inode's stats
1720 *
1721 * This may be called from the VFS directly, or from within GFS2 with the
1722 * inode locked, so we look to see if the glock is already locked and only
1723 * lock the glock if its not already been done. Note that its the NFS
1724 * readdirplus operation which causes this to be called (from filldir)
1725 * with the glock already held.
1726 *
1727 * Returns: errno
1728 */
1729
1730static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1731 struct kstat *stat)
1732{
1733 struct inode *inode = dentry->d_inode;
1734 struct gfs2_inode *ip = GFS2_I(inode);
1735 struct gfs2_holder gh;
1736 int error;
1737 int unlock = 0;
1738
1739 if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1740 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1741 if (error)
1742 return error;
1743 unlock = 1;
1744 }
1745
1746 generic_fillattr(inode, stat);
1747 if (unlock)
1748 gfs2_glock_dq_uninit(&gh);
1749
1750 return 0;
1751}
1752
1753static int gfs2_setxattr(struct dentry *dentry, const char *name,
1754 const void *data, size_t size, int flags)
1755{
1756 struct inode *inode = dentry->d_inode;
1757 struct gfs2_inode *ip = GFS2_I(inode);
1758 struct gfs2_holder gh;
1759 int ret;
1760
1761 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1762 ret = gfs2_glock_nq(&gh);
1763 if (ret == 0) {
1764 ret = generic_setxattr(dentry, name, data, size, flags);
1765 gfs2_glock_dq(&gh);
1766 }
1767 gfs2_holder_uninit(&gh);
1768 return ret;
1769}
1770
1771static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1772 void *data, size_t size)
1046{ 1773{
1047 struct gfs2_dinode *str = buf; 1774 struct inode *inode = dentry->d_inode;
1048 1775 struct gfs2_inode *ip = GFS2_I(inode);
1049 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 1776 struct gfs2_holder gh;
1050 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); 1777 int ret;
1051 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); 1778
1052 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr); 1779 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1053 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino); 1780 ret = gfs2_glock_nq(&gh);
1054 str->di_mode = cpu_to_be32(ip->i_inode.i_mode); 1781 if (ret == 0) {
1055 str->di_uid = cpu_to_be32(ip->i_inode.i_uid); 1782 ret = generic_getxattr(dentry, name, data, size);
1056 str->di_gid = cpu_to_be32(ip->i_inode.i_gid); 1783 gfs2_glock_dq(&gh);
1057 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); 1784 }
1058 str->di_size = cpu_to_be64(ip->i_disksize); 1785 gfs2_holder_uninit(&gh);
1059 str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode)); 1786 return ret;
1060 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1061 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
1062 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
1063
1064 str->di_goal_meta = cpu_to_be64(ip->i_goal);
1065 str->di_goal_data = cpu_to_be64(ip->i_goal);
1066 str->di_generation = cpu_to_be64(ip->i_generation);
1067
1068 str->di_flags = cpu_to_be32(ip->i_diskflags);
1069 str->di_height = cpu_to_be16(ip->i_height);
1070 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
1071 !(ip->i_diskflags & GFS2_DIF_EXHASH) ?
1072 GFS2_FORMAT_DE : 0);
1073 str->di_depth = cpu_to_be16(ip->i_depth);
1074 str->di_entries = cpu_to_be32(ip->i_entries);
1075
1076 str->di_eattr = cpu_to_be64(ip->i_eattr);
1077 str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
1078 str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
1079 str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
1080} 1787}
1081 1788
1082void gfs2_dinode_print(const struct gfs2_inode *ip) 1789static int gfs2_removexattr(struct dentry *dentry, const char *name)
1083{ 1790{
1084 printk(KERN_INFO " no_formal_ino = %llu\n", 1791 struct inode *inode = dentry->d_inode;
1085 (unsigned long long)ip->i_no_formal_ino); 1792 struct gfs2_inode *ip = GFS2_I(inode);
1086 printk(KERN_INFO " no_addr = %llu\n", 1793 struct gfs2_holder gh;
1087 (unsigned long long)ip->i_no_addr); 1794 int ret;
1088 printk(KERN_INFO " i_disksize = %llu\n", 1795
1089 (unsigned long long)ip->i_disksize); 1796 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1090 printk(KERN_INFO " blocks = %llu\n", 1797 ret = gfs2_glock_nq(&gh);
1091 (unsigned long long)gfs2_get_inode_blocks(&ip->i_inode)); 1798 if (ret == 0) {
1092 printk(KERN_INFO " i_goal = %llu\n", 1799 ret = generic_removexattr(dentry, name);
1093 (unsigned long long)ip->i_goal); 1800 gfs2_glock_dq(&gh);
1094 printk(KERN_INFO " i_diskflags = 0x%.8X\n", ip->i_diskflags); 1801 }
1095 printk(KERN_INFO " i_height = %u\n", ip->i_height); 1802 gfs2_holder_uninit(&gh);
1096 printk(KERN_INFO " i_depth = %u\n", ip->i_depth); 1803 return ret;
1097 printk(KERN_INFO " i_entries = %u\n", ip->i_entries);
1098 printk(KERN_INFO " i_eattr = %llu\n",
1099 (unsigned long long)ip->i_eattr);
1100} 1804}
1101 1805
1806static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1807 u64 start, u64 len)
1808{
1809 struct gfs2_inode *ip = GFS2_I(inode);
1810 struct gfs2_holder gh;
1811 int ret;
1812
1813 ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
1814 if (ret)
1815 return ret;
1816
1817 mutex_lock(&inode->i_mutex);
1818
1819 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1820 if (ret)
1821 goto out;
1822
1823 if (gfs2_is_stuffed(ip)) {
1824 u64 phys = ip->i_no_addr << inode->i_blkbits;
1825 u64 size = i_size_read(inode);
1826 u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
1827 FIEMAP_EXTENT_DATA_INLINE;
1828 phys += sizeof(struct gfs2_dinode);
1829 phys += start;
1830 if (start + len > size)
1831 len = size - start;
1832 if (start < size)
1833 ret = fiemap_fill_next_extent(fieinfo, start, phys,
1834 len, flags);
1835 if (ret == 1)
1836 ret = 0;
1837 } else {
1838 ret = __generic_block_fiemap(inode, fieinfo, start, len,
1839 gfs2_block_map);
1840 }
1841
1842 gfs2_glock_dq_uninit(&gh);
1843out:
1844 mutex_unlock(&inode->i_mutex);
1845 return ret;
1846}
1847
1848const struct inode_operations gfs2_file_iops = {
1849 .permission = gfs2_permission,
1850 .setattr = gfs2_setattr,
1851 .getattr = gfs2_getattr,
1852 .setxattr = gfs2_setxattr,
1853 .getxattr = gfs2_getxattr,
1854 .listxattr = gfs2_listxattr,
1855 .removexattr = gfs2_removexattr,
1856 .fiemap = gfs2_fiemap,
1857};
1858
1859const struct inode_operations gfs2_dir_iops = {
1860 .create = gfs2_create,
1861 .lookup = gfs2_lookup,
1862 .link = gfs2_link,
1863 .unlink = gfs2_unlink,
1864 .symlink = gfs2_symlink,
1865 .mkdir = gfs2_mkdir,
1866 .rmdir = gfs2_unlink,
1867 .mknod = gfs2_mknod,
1868 .rename = gfs2_rename,
1869 .permission = gfs2_permission,
1870 .setattr = gfs2_setattr,
1871 .getattr = gfs2_getattr,
1872 .setxattr = gfs2_setxattr,
1873 .getxattr = gfs2_getxattr,
1874 .listxattr = gfs2_listxattr,
1875 .removexattr = gfs2_removexattr,
1876 .fiemap = gfs2_fiemap,
1877};
1878
1879const struct inode_operations gfs2_symlink_iops = {
1880 .readlink = generic_readlink,
1881 .follow_link = gfs2_follow_link,
1882 .put_link = gfs2_put_link,
1883 .permission = gfs2_permission,
1884 .setattr = gfs2_setattr,
1885 .getattr = gfs2_getattr,
1886 .setxattr = gfs2_setxattr,
1887 .getxattr = gfs2_getxattr,
1888 .listxattr = gfs2_listxattr,
1889 .removexattr = gfs2_removexattr,
1890 .fiemap = gfs2_fiemap,
1891};
1892
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-12 14:27:39 -0400