Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit e9bd2b3bafd29bf75522546207f0bba0ec4515c2

Authored by Wendy Cheng
Committed by Steven Whitehouse
1 parent c4f68a130f
Exists in master and in 20 other branches dlt-processor-sdk-linux-03.00.00.04, newt-ti-linux-3.12.y, processor-sdk-linux-01.00.00, processor-sdk-linux-02.00.01, smarc-ti-linux-3.12.10, smarc-ti-linux-3.12.y, smarc-ti-linux-3.14.y, smarc-ti-linux-3.15.y, smarc-ti-lsk-linux-4.1.y, smarct3x-processor-sdk-04.01.00.06, smarct3x-processor-sdk-linux-02.00.01, smarct3x-processor-sdk-linux-03.00.00.04, smarct4x-800-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-04.01.00.06, smarct4x-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-linux-03.00.00.04, ti-linux-3.12.y, ti-linux-3.14.y, ti-linux-3.15.y, ti-lsk-linux-4.1.y

[GFS2] fix inode meta data corruption 

Fix a nasty inode meta data corruption issue by keeping the buffer head in
icache array. This buffer needs to stay in memory until journal flush occurs
Otherwise, gfs2_meta_inode_buffer could do a disk read before the inode hits
disk. It ends up with meta data corruptions. The buffer will be released as
part of the existing journal flush logic.

Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Showing 1 changed file with 15 additions and 5 deletions Inline Diff

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-2006 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2006 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> 10 #include <linux/sched.h>
11 #include <linux/slab.h> 11 #include <linux/slab.h>
12 #include <linux/spinlock.h> 12 #include <linux/spinlock.h>
13 #include <linux/completion.h> 13 #include <linux/completion.h>
14 #include <linux/buffer_head.h> 14 #include <linux/buffer_head.h>
15 #include <linux/posix_acl.h> 15 #include <linux/posix_acl.h>
16 #include <linux/sort.h> 16 #include <linux/sort.h>
17 #include <linux/gfs2_ondisk.h> 17 #include <linux/gfs2_ondisk.h>
18 #include <linux/crc32.h> 18 #include <linux/crc32.h>
19 #include <linux/lm_interface.h> 19 #include <linux/lm_interface.h>
20 #include <linux/security.h> 20 #include <linux/security.h>
21 21
22 #include "gfs2.h" 22 #include "gfs2.h"
23 #include "incore.h" 23 #include "incore.h"
24 #include "acl.h" 24 #include "acl.h"
25 #include "bmap.h" 25 #include "bmap.h"
26 #include "dir.h" 26 #include "dir.h"
27 #include "eattr.h" 27 #include "eattr.h"
28 #include "glock.h" 28 #include "glock.h"
29 #include "glops.h" 29 #include "glops.h"
30 #include "inode.h" 30 #include "inode.h"
31 #include "log.h" 31 #include "log.h"
32 #include "meta_io.h" 32 #include "meta_io.h"
33 #include "ops_address.h" 33 #include "ops_address.h"
34 #include "ops_file.h" 34 #include "ops_file.h"
35 #include "ops_inode.h" 35 #include "ops_inode.h"
36 #include "quota.h" 36 #include "quota.h"
37 #include "rgrp.h" 37 #include "rgrp.h"
38 #include "trans.h" 38 #include "trans.h"
39 #include "util.h" 39 #include "util.h"
40 40
41 struct gfs2_inum_range_host { 41 struct gfs2_inum_range_host {
42 u64 ir_start; 42 u64 ir_start;
43 u64 ir_length; 43 u64 ir_length;
44 }; 44 };
45 45
46 static int iget_test(struct inode *inode, void *opaque) 46 static int iget_test(struct inode *inode, void *opaque)
47 { 47 {
48 struct gfs2_inode *ip = GFS2_I(inode); 48 struct gfs2_inode *ip = GFS2_I(inode);
49 u64 *no_addr = opaque; 49 u64 *no_addr = opaque;
50 50
51 if (ip->i_no_addr == *no_addr && 51 if (ip->i_no_addr == *no_addr &&
52 inode->i_private != NULL) 52 inode->i_private != NULL)
53 return 1; 53 return 1;
54 54
55 return 0; 55 return 0;
56 } 56 }
57 57
58 static int iget_set(struct inode *inode, void *opaque) 58 static int iget_set(struct inode *inode, void *opaque)
59 { 59 {
60 struct gfs2_inode *ip = GFS2_I(inode); 60 struct gfs2_inode *ip = GFS2_I(inode);
61 u64 *no_addr = opaque; 61 u64 *no_addr = opaque;
62 62
63 inode->i_ino = (unsigned long)*no_addr; 63 inode->i_ino = (unsigned long)*no_addr;
64 ip->i_no_addr = *no_addr; 64 ip->i_no_addr = *no_addr;
65 return 0; 65 return 0;
66 } 66 }
67 67
68 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr) 68 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
69 { 69 {
70 unsigned long hash = (unsigned long)no_addr; 70 unsigned long hash = (unsigned long)no_addr;
71 return ilookup5(sb, hash, iget_test, &no_addr); 71 return ilookup5(sb, hash, iget_test, &no_addr);
72 } 72 }
73 73
74 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr) 74 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
75 { 75 {
76 unsigned long hash = (unsigned long)no_addr; 76 unsigned long hash = (unsigned long)no_addr;
77 return iget5_locked(sb, hash, iget_test, iget_set, &no_addr); 77 return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
78 } 78 }
79 79
80 /** 80 /**
81 * GFS2 lookup code fills in vfs inode contents based on info obtained 81 * GFS2 lookup code fills in vfs inode contents based on info obtained
82 * from directory entry inside gfs2_inode_lookup(). This has caused issues 82 * from directory entry inside gfs2_inode_lookup(). This has caused issues
83 * with NFS code path since its get_dentry routine doesn't have the relevant 83 * with NFS code path since its get_dentry routine doesn't have the relevant
84 * directory entry when gfs2_inode_lookup() is invoked. Part of the code 84 * directory entry when gfs2_inode_lookup() is invoked. Part of the code
85 * segment inside gfs2_inode_lookup code needs to get moved around. 85 * segment inside gfs2_inode_lookup code needs to get moved around.
86 * 86 *
87 * Clean up I_LOCK and I_NEW as well. 87 * Clean up I_LOCK and I_NEW as well.
88 **/ 88 **/
89 89
90 void gfs2_set_iop(struct inode *inode) 90 void gfs2_set_iop(struct inode *inode)
91 { 91 {
92 umode_t mode = inode->i_mode; 92 umode_t mode = inode->i_mode;
93 93
94 if (S_ISREG(mode)) { 94 if (S_ISREG(mode)) {
95 inode->i_op = &gfs2_file_iops; 95 inode->i_op = &gfs2_file_iops;
96 inode->i_fop = &gfs2_file_fops; 96 inode->i_fop = &gfs2_file_fops;
97 inode->i_mapping->a_ops = &gfs2_file_aops; 97 inode->i_mapping->a_ops = &gfs2_file_aops;
98 } else if (S_ISDIR(mode)) { 98 } else if (S_ISDIR(mode)) {
99 inode->i_op = &gfs2_dir_iops; 99 inode->i_op = &gfs2_dir_iops;
100 inode->i_fop = &gfs2_dir_fops; 100 inode->i_fop = &gfs2_dir_fops;
101 } else if (S_ISLNK(mode)) { 101 } else if (S_ISLNK(mode)) {
102 inode->i_op = &gfs2_symlink_iops; 102 inode->i_op = &gfs2_symlink_iops;
103 } else { 103 } else {
104 inode->i_op = &gfs2_dev_iops; 104 inode->i_op = &gfs2_dev_iops;
105 } 105 }
106 106
107 unlock_new_inode(inode); 107 unlock_new_inode(inode);
108 } 108 }
109 109
110 /** 110 /**
111 * gfs2_inode_lookup - Lookup an inode 111 * gfs2_inode_lookup - Lookup an inode
112 * @sb: The super block 112 * @sb: The super block
113 * @no_addr: The inode number 113 * @no_addr: The inode number
114 * @type: The type of the inode 114 * @type: The type of the inode
115 * 115 *
116 * Returns: A VFS inode, or an error 116 * Returns: A VFS inode, or an error
117 */ 117 */
118 118
119 struct inode *gfs2_inode_lookup(struct super_block *sb, 119 struct inode *gfs2_inode_lookup(struct super_block *sb,
120 unsigned int type, 120 unsigned int type,
121 u64 no_addr, 121 u64 no_addr,
122 u64 no_formal_ino) 122 u64 no_formal_ino)
123 { 123 {
124 struct inode *inode = gfs2_iget(sb, no_addr); 124 struct inode *inode = gfs2_iget(sb, no_addr);
125 struct gfs2_inode *ip = GFS2_I(inode); 125 struct gfs2_inode *ip = GFS2_I(inode);
126 struct gfs2_glock *io_gl; 126 struct gfs2_glock *io_gl;
127 int error; 127 int error;
128 128
129 if (!inode) 129 if (!inode)
130 return ERR_PTR(-ENOBUFS); 130 return ERR_PTR(-ENOBUFS);
131 131
132 if (inode->i_state & I_NEW) { 132 if (inode->i_state & I_NEW) {
133 struct gfs2_sbd *sdp = GFS2_SB(inode); 133 struct gfs2_sbd *sdp = GFS2_SB(inode);
134 inode->i_private = ip; 134 inode->i_private = ip;
135 ip->i_no_formal_ino = no_formal_ino; 135 ip->i_no_formal_ino = no_formal_ino;
136 136
137 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl); 137 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
138 if (unlikely(error)) 138 if (unlikely(error))
139 goto fail; 139 goto fail;
140 ip->i_gl->gl_object = ip; 140 ip->i_gl->gl_object = ip;
141 141
142 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl); 142 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
143 if (unlikely(error)) 143 if (unlikely(error))
144 goto fail_put; 144 goto fail_put;
145 145
146 set_bit(GIF_INVALID, &ip->i_flags); 146 set_bit(GIF_INVALID, &ip->i_flags);
147 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh); 147 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
148 if (unlikely(error)) 148 if (unlikely(error))
149 goto fail_iopen; 149 goto fail_iopen;
150 ip->i_iopen_gh.gh_gl->gl_object = ip; 150 ip->i_iopen_gh.gh_gl->gl_object = ip;
151 151
152 gfs2_glock_put(io_gl); 152 gfs2_glock_put(io_gl);
153 153
154 if ((type == DT_UNKNOWN) && (no_formal_ino == 0)) 154 if ((type == DT_UNKNOWN) && (no_formal_ino == 0))
155 goto gfs2_nfsbypass; 155 goto gfs2_nfsbypass;
156 156
157 inode->i_mode = DT2IF(type); 157 inode->i_mode = DT2IF(type);
158 158
159 /* 159 /*
160 * We must read the inode in order to work out its type in 160 * We must read the inode in order to work out its type in
161 * this case. Note that this doesn't happen often as we normally 161 * this case. Note that this doesn't happen often as we normally
162 * know the type beforehand. This code path only occurs during 162 * know the type beforehand. This code path only occurs during
163 * unlinked inode recovery (where it is safe to do this glock, 163 * unlinked inode recovery (where it is safe to do this glock,
164 * which is not true in the general case). 164 * which is not true in the general case).
165 */ 165 */
166 if (type == DT_UNKNOWN) { 166 if (type == DT_UNKNOWN) {
167 struct gfs2_holder gh; 167 struct gfs2_holder gh;
168 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 168 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
169 if (unlikely(error)) 169 if (unlikely(error))
170 goto fail_glock; 170 goto fail_glock;
171 /* Inode is now uptodate */ 171 /* Inode is now uptodate */
172 gfs2_glock_dq_uninit(&gh); 172 gfs2_glock_dq_uninit(&gh);
173 } 173 }
174 174
175 gfs2_set_iop(inode); 175 gfs2_set_iop(inode);
176 } 176 }
177 177
178 gfs2_nfsbypass: 178 gfs2_nfsbypass:
179 return inode; 179 return inode;
180 fail_glock: 180 fail_glock:
181 gfs2_glock_dq(&ip->i_iopen_gh); 181 gfs2_glock_dq(&ip->i_iopen_gh);
182 fail_iopen: 182 fail_iopen:
183 gfs2_glock_put(io_gl); 183 gfs2_glock_put(io_gl);
184 fail_put: 184 fail_put:
185 ip->i_gl->gl_object = NULL; 185 ip->i_gl->gl_object = NULL;
186 gfs2_glock_put(ip->i_gl); 186 gfs2_glock_put(ip->i_gl);
187 fail: 187 fail:
188 iput(inode); 188 iput(inode);
189 return ERR_PTR(error); 189 return ERR_PTR(error);
190 } 190 }
191 191
192 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf) 192 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
193 { 193 {
194 struct gfs2_dinode_host *di = &ip->i_di; 194 struct gfs2_dinode_host *di = &ip->i_di;
195 const struct gfs2_dinode *str = buf; 195 const struct gfs2_dinode *str = buf;
196 196
197 if (ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)) { 197 if (ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)) {
198 if (gfs2_consist_inode(ip)) 198 if (gfs2_consist_inode(ip))
199 gfs2_dinode_print(ip); 199 gfs2_dinode_print(ip);
200 return -EIO; 200 return -EIO;
201 } 201 }
202 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino); 202 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
203 ip->i_inode.i_mode = be32_to_cpu(str->di_mode); 203 ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
204 ip->i_inode.i_rdev = 0; 204 ip->i_inode.i_rdev = 0;
205 switch (ip->i_inode.i_mode & S_IFMT) { 205 switch (ip->i_inode.i_mode & S_IFMT) {
206 case S_IFBLK: 206 case S_IFBLK:
207 case S_IFCHR: 207 case S_IFCHR:
208 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major), 208 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
209 be32_to_cpu(str->di_minor)); 209 be32_to_cpu(str->di_minor));
210 break; 210 break;
211 }; 211 };
212 212
213 ip->i_inode.i_uid = be32_to_cpu(str->di_uid); 213 ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
214 ip->i_inode.i_gid = be32_to_cpu(str->di_gid); 214 ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
215 /* 215 /*
216 * We will need to review setting the nlink count here in the 216 * We will need to review setting the nlink count here in the
217 * light of the forthcoming ro bind mount work. This is a reminder 217 * light of the forthcoming ro bind mount work. This is a reminder
218 * to do that. 218 * to do that.
219 */ 219 */
220 ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink); 220 ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
221 di->di_size = be64_to_cpu(str->di_size); 221 di->di_size = be64_to_cpu(str->di_size);
222 i_size_write(&ip->i_inode, di->di_size); 222 i_size_write(&ip->i_inode, di->di_size);
223 di->di_blocks = be64_to_cpu(str->di_blocks); 223 di->di_blocks = be64_to_cpu(str->di_blocks);
224 gfs2_set_inode_blocks(&ip->i_inode); 224 gfs2_set_inode_blocks(&ip->i_inode);
225 ip->i_inode.i_atime.tv_sec = be64_to_cpu(str->di_atime); 225 ip->i_inode.i_atime.tv_sec = be64_to_cpu(str->di_atime);
226 ip->i_inode.i_atime.tv_nsec = be32_to_cpu(str->di_atime_nsec); 226 ip->i_inode.i_atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
227 ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime); 227 ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
228 ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec); 228 ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
229 ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime); 229 ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
230 ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec); 230 ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
231 231
232 di->di_goal_meta = be64_to_cpu(str->di_goal_meta); 232 di->di_goal_meta = be64_to_cpu(str->di_goal_meta);
233 di->di_goal_data = be64_to_cpu(str->di_goal_data); 233 di->di_goal_data = be64_to_cpu(str->di_goal_data);
234 di->di_generation = be64_to_cpu(str->di_generation); 234 di->di_generation = be64_to_cpu(str->di_generation);
235 235
236 di->di_flags = be32_to_cpu(str->di_flags); 236 di->di_flags = be32_to_cpu(str->di_flags);
237 gfs2_set_inode_flags(&ip->i_inode); 237 gfs2_set_inode_flags(&ip->i_inode);
238 di->di_height = be16_to_cpu(str->di_height); 238 di->di_height = be16_to_cpu(str->di_height);
239 239
240 di->di_depth = be16_to_cpu(str->di_depth); 240 di->di_depth = be16_to_cpu(str->di_depth);
241 di->di_entries = be32_to_cpu(str->di_entries); 241 di->di_entries = be32_to_cpu(str->di_entries);
242 242
243 di->di_eattr = be64_to_cpu(str->di_eattr); 243 di->di_eattr = be64_to_cpu(str->di_eattr);
244 return 0; 244 return 0;
245 } 245 }
246 246
247 static void gfs2_inode_bh(struct gfs2_inode *ip, struct buffer_head *bh)
248 {
249 ip->i_cache[0] = bh;
250 }
251
247 /** 252 /**
248 * gfs2_inode_refresh - Refresh the incore copy of the dinode 253 * gfs2_inode_refresh - Refresh the incore copy of the dinode
249 * @ip: The GFS2 inode 254 * @ip: The GFS2 inode
250 * 255 *
251 * Returns: errno 256 * Returns: errno
252 */ 257 */
253 258
254 int gfs2_inode_refresh(struct gfs2_inode *ip) 259 int gfs2_inode_refresh(struct gfs2_inode *ip)
255 { 260 {
256 struct buffer_head *dibh; 261 struct buffer_head *dibh;
257 int error; 262 int error;
258 263
259 error = gfs2_meta_inode_buffer(ip, &dibh); 264 error = gfs2_meta_inode_buffer(ip, &dibh);
260 if (error) 265 if (error)
261 return error; 266 return error;
262 267
263 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) { 268 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
264 brelse(dibh); 269 brelse(dibh);
265 return -EIO; 270 return -EIO;
266 } 271 }
267 272
268 error = gfs2_dinode_in(ip, dibh->b_data); 273 error = gfs2_dinode_in(ip, dibh->b_data);
269 brelse(dibh); 274 brelse(dibh);
270 clear_bit(GIF_INVALID, &ip->i_flags); 275 clear_bit(GIF_INVALID, &ip->i_flags);
271 276
272 return error; 277 return error;
273 } 278 }
274 279
275 int gfs2_dinode_dealloc(struct gfs2_inode *ip) 280 int gfs2_dinode_dealloc(struct gfs2_inode *ip)
276 { 281 {
277 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 282 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
278 struct gfs2_alloc *al; 283 struct gfs2_alloc *al;
279 struct gfs2_rgrpd *rgd; 284 struct gfs2_rgrpd *rgd;
280 int error; 285 int error;
281 286
282 if (ip->i_di.di_blocks != 1) { 287 if (ip->i_di.di_blocks != 1) {
283 if (gfs2_consist_inode(ip)) 288 if (gfs2_consist_inode(ip))
284 gfs2_dinode_print(ip); 289 gfs2_dinode_print(ip);
285 return -EIO; 290 return -EIO;
286 } 291 }
287 292
288 al = gfs2_alloc_get(ip); 293 al = gfs2_alloc_get(ip);
289 294
290 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 295 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
291 if (error) 296 if (error)
292 goto out; 297 goto out;
293 298
294 error = gfs2_rindex_hold(sdp, &al->al_ri_gh); 299 error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
295 if (error) 300 if (error)
296 goto out_qs; 301 goto out_qs;
297 302
298 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr); 303 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
299 if (!rgd) { 304 if (!rgd) {
300 gfs2_consist_inode(ip); 305 gfs2_consist_inode(ip);
301 error = -EIO; 306 error = -EIO;
302 goto out_rindex_relse; 307 goto out_rindex_relse;
303 } 308 }
304 309
305 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, 310 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
306 &al->al_rgd_gh); 311 &al->al_rgd_gh);
307 if (error) 312 if (error)
308 goto out_rindex_relse; 313 goto out_rindex_relse;
309 314
310 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1); 315 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
311 if (error) 316 if (error)
312 goto out_rg_gunlock; 317 goto out_rg_gunlock;
313 318
314 gfs2_trans_add_gl(ip->i_gl); 319 gfs2_trans_add_gl(ip->i_gl);
315 320
316 gfs2_free_di(rgd, ip); 321 gfs2_free_di(rgd, ip);
317 322
318 gfs2_trans_end(sdp); 323 gfs2_trans_end(sdp);
319 clear_bit(GLF_STICKY, &ip->i_gl->gl_flags); 324 clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
320 325
321 out_rg_gunlock: 326 out_rg_gunlock:
322 gfs2_glock_dq_uninit(&al->al_rgd_gh); 327 gfs2_glock_dq_uninit(&al->al_rgd_gh);
323 out_rindex_relse: 328 out_rindex_relse:
324 gfs2_glock_dq_uninit(&al->al_ri_gh); 329 gfs2_glock_dq_uninit(&al->al_ri_gh);
325 out_qs: 330 out_qs:
326 gfs2_quota_unhold(ip); 331 gfs2_quota_unhold(ip);
327 out: 332 out:
328 gfs2_alloc_put(ip); 333 gfs2_alloc_put(ip);
329 return error; 334 return error;
330 } 335 }
331 336
332 /** 337 /**
333 * gfs2_change_nlink - Change nlink count on inode 338 * gfs2_change_nlink - Change nlink count on inode
334 * @ip: The GFS2 inode 339 * @ip: The GFS2 inode
335 * @diff: The change in the nlink count required 340 * @diff: The change in the nlink count required
336 * 341 *
337 * Returns: errno 342 * Returns: errno
338 */ 343 */
339 int gfs2_change_nlink(struct gfs2_inode *ip, int diff) 344 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
340 { 345 {
341 struct buffer_head *dibh; 346 struct buffer_head *dibh;
342 u32 nlink; 347 u32 nlink;
343 int error; 348 int error;
344 349
345 BUG_ON(diff != 1 && diff != -1); 350 BUG_ON(diff != 1 && diff != -1);
346 nlink = ip->i_inode.i_nlink + diff; 351 nlink = ip->i_inode.i_nlink + diff;
347 352
348 /* If we are reducing the nlink count, but the new value ends up being 353 /* If we are reducing the nlink count, but the new value ends up being
349 bigger than the old one, we must have underflowed. */ 354 bigger than the old one, we must have underflowed. */
350 if (diff < 0 && nlink > ip->i_inode.i_nlink) { 355 if (diff < 0 && nlink > ip->i_inode.i_nlink) {
351 if (gfs2_consist_inode(ip)) 356 if (gfs2_consist_inode(ip))
352 gfs2_dinode_print(ip); 357 gfs2_dinode_print(ip);
353 return -EIO; 358 return -EIO;
354 } 359 }
355 360
356 error = gfs2_meta_inode_buffer(ip, &dibh); 361 error = gfs2_meta_inode_buffer(ip, &dibh);
357 if (error) 362 if (error)
358 return error; 363 return error;
359 364
360 if (diff > 0) 365 if (diff > 0)
361 inc_nlink(&ip->i_inode); 366 inc_nlink(&ip->i_inode);
362 else 367 else
363 drop_nlink(&ip->i_inode); 368 drop_nlink(&ip->i_inode);
364 369
365 ip->i_inode.i_ctime = CURRENT_TIME; 370 ip->i_inode.i_ctime = CURRENT_TIME;
366 371
367 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 372 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
368 gfs2_dinode_out(ip, dibh->b_data); 373 gfs2_dinode_out(ip, dibh->b_data);
369 brelse(dibh); 374 brelse(dibh);
370 mark_inode_dirty(&ip->i_inode); 375 mark_inode_dirty(&ip->i_inode);
371 376
372 if (ip->i_inode.i_nlink == 0) 377 if (ip->i_inode.i_nlink == 0)
373 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */ 378 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
374 379
375 return error; 380 return error;
376 } 381 }
377 382
378 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name) 383 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
379 { 384 {
380 struct qstr qstr; 385 struct qstr qstr;
381 struct inode *inode; 386 struct inode *inode;
382 gfs2_str2qstr(&qstr, name); 387 gfs2_str2qstr(&qstr, name);
383 inode = gfs2_lookupi(dip, &qstr, 1, NULL); 388 inode = gfs2_lookupi(dip, &qstr, 1, NULL);
384 /* gfs2_lookupi has inconsistent callers: vfs 389 /* gfs2_lookupi has inconsistent callers: vfs
385 * related routines expect NULL for no entry found, 390 * related routines expect NULL for no entry found,
386 * gfs2_lookup_simple callers expect ENOENT 391 * gfs2_lookup_simple callers expect ENOENT
387 * and do not check for NULL. 392 * and do not check for NULL.
388 */ 393 */
389 if (inode == NULL) 394 if (inode == NULL)
390 return ERR_PTR(-ENOENT); 395 return ERR_PTR(-ENOENT);
391 else 396 else
392 return inode; 397 return inode;
393 } 398 }
394 399
395 400
396 /** 401 /**
397 * gfs2_lookupi - Look up a filename in a directory and return its inode 402 * gfs2_lookupi - Look up a filename in a directory and return its inode
398 * @d_gh: An initialized holder for the directory glock 403 * @d_gh: An initialized holder for the directory glock
399 * @name: The name of the inode to look for 404 * @name: The name of the inode to look for
400 * @is_root: If 1, ignore the caller's permissions 405 * @is_root: If 1, ignore the caller's permissions
401 * @i_gh: An uninitialized holder for the new inode glock 406 * @i_gh: An uninitialized holder for the new inode glock
402 * 407 *
403 * This can be called via the VFS filldir function when NFS is doing 408 * This can be called via the VFS filldir function when NFS is doing
404 * a readdirplus and the inode which its intending to stat isn't 409 * a readdirplus and the inode which its intending to stat isn't
405 * already in cache. In this case we must not take the directory glock 410 * already in cache. In this case we must not take the directory glock
406 * again, since the readdir call will have already taken that lock. 411 * again, since the readdir call will have already taken that lock.
407 * 412 *
408 * Returns: errno 413 * Returns: errno
409 */ 414 */
410 415
411 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name, 416 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
412 int is_root, struct nameidata *nd) 417 int is_root, struct nameidata *nd)
413 { 418 {
414 struct super_block *sb = dir->i_sb; 419 struct super_block *sb = dir->i_sb;
415 struct gfs2_inode *dip = GFS2_I(dir); 420 struct gfs2_inode *dip = GFS2_I(dir);
416 struct gfs2_holder d_gh; 421 struct gfs2_holder d_gh;
417 int error = 0; 422 int error = 0;
418 struct inode *inode = NULL; 423 struct inode *inode = NULL;
419 int unlock = 0; 424 int unlock = 0;
420 425
421 if (!name->len || name->len > GFS2_FNAMESIZE) 426 if (!name->len || name->len > GFS2_FNAMESIZE)
422 return ERR_PTR(-ENAMETOOLONG); 427 return ERR_PTR(-ENAMETOOLONG);
423 428
424 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) || 429 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
425 (name->len == 2 && memcmp(name->name, "..", 2) == 0 && 430 (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
426 dir == sb->s_root->d_inode)) { 431 dir == sb->s_root->d_inode)) {
427 igrab(dir); 432 igrab(dir);
428 return dir; 433 return dir;
429 } 434 }
430 435
431 if (gfs2_glock_is_locked_by_me(dip->i_gl) == 0) { 436 if (gfs2_glock_is_locked_by_me(dip->i_gl) == 0) {
432 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh); 437 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
433 if (error) 438 if (error)
434 return ERR_PTR(error); 439 return ERR_PTR(error);
435 unlock = 1; 440 unlock = 1;
436 } 441 }
437 442
438 if (!is_root) { 443 if (!is_root) {
439 error = permission(dir, MAY_EXEC, NULL); 444 error = permission(dir, MAY_EXEC, NULL);
440 if (error) 445 if (error)
441 goto out; 446 goto out;
442 } 447 }
443 448
444 inode = gfs2_dir_search(dir, name); 449 inode = gfs2_dir_search(dir, name);
445 if (IS_ERR(inode)) 450 if (IS_ERR(inode))
446 error = PTR_ERR(inode); 451 error = PTR_ERR(inode);
447 out: 452 out:
448 if (unlock) 453 if (unlock)
449 gfs2_glock_dq_uninit(&d_gh); 454 gfs2_glock_dq_uninit(&d_gh);
450 if (error == -ENOENT) 455 if (error == -ENOENT)
451 return NULL; 456 return NULL;
452 return inode ? inode : ERR_PTR(error); 457 return inode ? inode : ERR_PTR(error);
453 } 458 }
454 459
455 static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf) 460 static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
456 { 461 {
457 const struct gfs2_inum_range *str = buf; 462 const struct gfs2_inum_range *str = buf;
458 463
459 ir->ir_start = be64_to_cpu(str->ir_start); 464 ir->ir_start = be64_to_cpu(str->ir_start);
460 ir->ir_length = be64_to_cpu(str->ir_length); 465 ir->ir_length = be64_to_cpu(str->ir_length);
461 } 466 }
462 467
463 static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf) 468 static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
464 { 469 {
465 struct gfs2_inum_range *str = buf; 470 struct gfs2_inum_range *str = buf;
466 471
467 str->ir_start = cpu_to_be64(ir->ir_start); 472 str->ir_start = cpu_to_be64(ir->ir_start);
468 str->ir_length = cpu_to_be64(ir->ir_length); 473 str->ir_length = cpu_to_be64(ir->ir_length);
469 } 474 }
470 475
471 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino) 476 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
472 { 477 {
473 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 478 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
474 struct buffer_head *bh; 479 struct buffer_head *bh;
475 struct gfs2_inum_range_host ir; 480 struct gfs2_inum_range_host ir;
476 int error; 481 int error;
477 482
478 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 483 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
479 if (error) 484 if (error)
480 return error; 485 return error;
481 mutex_lock(&sdp->sd_inum_mutex); 486 mutex_lock(&sdp->sd_inum_mutex);
482 487
483 error = gfs2_meta_inode_buffer(ip, &bh); 488 error = gfs2_meta_inode_buffer(ip, &bh);
484 if (error) { 489 if (error) {
485 mutex_unlock(&sdp->sd_inum_mutex); 490 mutex_unlock(&sdp->sd_inum_mutex);
486 gfs2_trans_end(sdp); 491 gfs2_trans_end(sdp);
487 return error; 492 return error;
488 } 493 }
489 494
490 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 495 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
491 496
492 if (ir.ir_length) { 497 if (ir.ir_length) {
493 *formal_ino = ir.ir_start++; 498 *formal_ino = ir.ir_start++;
494 ir.ir_length--; 499 ir.ir_length--;
495 gfs2_trans_add_bh(ip->i_gl, bh, 1); 500 gfs2_trans_add_bh(ip->i_gl, bh, 1);
496 gfs2_inum_range_out(&ir, 501 gfs2_inum_range_out(&ir,
497 bh->b_data + sizeof(struct gfs2_dinode)); 502 bh->b_data + sizeof(struct gfs2_dinode));
498 brelse(bh); 503 brelse(bh);
499 mutex_unlock(&sdp->sd_inum_mutex); 504 mutex_unlock(&sdp->sd_inum_mutex);
500 gfs2_trans_end(sdp); 505 gfs2_trans_end(sdp);
501 return 0; 506 return 0;
502 } 507 }
503 508
504 brelse(bh); 509 brelse(bh);
505 510
506 mutex_unlock(&sdp->sd_inum_mutex); 511 mutex_unlock(&sdp->sd_inum_mutex);
507 gfs2_trans_end(sdp); 512 gfs2_trans_end(sdp);
508 513
509 return 1; 514 return 1;
510 } 515 }
511 516
512 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino) 517 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
513 { 518 {
514 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 519 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
515 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode); 520 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
516 struct gfs2_holder gh; 521 struct gfs2_holder gh;
517 struct buffer_head *bh; 522 struct buffer_head *bh;
518 struct gfs2_inum_range_host ir; 523 struct gfs2_inum_range_host ir;
519 int error; 524 int error;
520 525
521 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 526 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
522 if (error) 527 if (error)
523 return error; 528 return error;
524 529
525 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0); 530 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
526 if (error) 531 if (error)
527 goto out; 532 goto out;
528 mutex_lock(&sdp->sd_inum_mutex); 533 mutex_lock(&sdp->sd_inum_mutex);
529 534
530 error = gfs2_meta_inode_buffer(ip, &bh); 535 error = gfs2_meta_inode_buffer(ip, &bh);
531 if (error) 536 if (error)
532 goto out_end_trans; 537 goto out_end_trans;
533 538
534 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 539 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
535 540
536 if (!ir.ir_length) { 541 if (!ir.ir_length) {
537 struct buffer_head *m_bh; 542 struct buffer_head *m_bh;
538 u64 x, y; 543 u64 x, y;
539 __be64 z; 544 __be64 z;
540 545
541 error = gfs2_meta_inode_buffer(m_ip, &m_bh); 546 error = gfs2_meta_inode_buffer(m_ip, &m_bh);
542 if (error) 547 if (error)
543 goto out_brelse; 548 goto out_brelse;
544 549
545 z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)); 550 z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
546 x = y = be64_to_cpu(z); 551 x = y = be64_to_cpu(z);
547 ir.ir_start = x; 552 ir.ir_start = x;
548 ir.ir_length = GFS2_INUM_QUANTUM; 553 ir.ir_length = GFS2_INUM_QUANTUM;
549 x += GFS2_INUM_QUANTUM; 554 x += GFS2_INUM_QUANTUM;
550 if (x < y) 555 if (x < y)
551 gfs2_consist_inode(m_ip); 556 gfs2_consist_inode(m_ip);
552 z = cpu_to_be64(x); 557 z = cpu_to_be64(x);
553 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1); 558 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
554 *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z; 559 *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z;
555 560
556 brelse(m_bh); 561 brelse(m_bh);
557 } 562 }
558 563
559 *formal_ino = ir.ir_start++; 564 *formal_ino = ir.ir_start++;
560 ir.ir_length--; 565 ir.ir_length--;
561 566
562 gfs2_trans_add_bh(ip->i_gl, bh, 1); 567 gfs2_trans_add_bh(ip->i_gl, bh, 1);
563 gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 568 gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
564 569
565 out_brelse: 570 out_brelse:
566 brelse(bh); 571 brelse(bh);
567 out_end_trans: 572 out_end_trans:
568 mutex_unlock(&sdp->sd_inum_mutex); 573 mutex_unlock(&sdp->sd_inum_mutex);
569 gfs2_trans_end(sdp); 574 gfs2_trans_end(sdp);
570 out: 575 out:
571 gfs2_glock_dq_uninit(&gh); 576 gfs2_glock_dq_uninit(&gh);
572 return error; 577 return error;
573 } 578 }
574 579
575 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum) 580 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
576 { 581 {
577 int error; 582 int error;
578 583
579 error = pick_formal_ino_1(sdp, inum); 584 error = pick_formal_ino_1(sdp, inum);
580 if (error <= 0) 585 if (error <= 0)
581 return error; 586 return error;
582 587
583 error = pick_formal_ino_2(sdp, inum); 588 error = pick_formal_ino_2(sdp, inum);
584 589
585 return error; 590 return error;
586 } 591 }
587 592
588 /** 593 /**
589 * create_ok - OK to create a new on-disk inode here? 594 * create_ok - OK to create a new on-disk inode here?
590 * @dip: Directory in which dinode is to be created 595 * @dip: Directory in which dinode is to be created
591 * @name: Name of new dinode 596 * @name: Name of new dinode
592 * @mode: 597 * @mode:
593 * 598 *
594 * Returns: errno 599 * Returns: errno
595 */ 600 */
596 601
597 static int create_ok(struct gfs2_inode *dip, const struct qstr *name, 602 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
598 unsigned int mode) 603 unsigned int mode)
599 { 604 {
600 int error; 605 int error;
601 606
602 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL); 607 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
603 if (error) 608 if (error)
604 return error; 609 return error;
605 610
606 /* Don't create entries in an unlinked directory */ 611 /* Don't create entries in an unlinked directory */
607 if (!dip->i_inode.i_nlink) 612 if (!dip->i_inode.i_nlink)
608 return -EPERM; 613 return -EPERM;
609 614
610 error = gfs2_dir_check(&dip->i_inode, name, NULL); 615 error = gfs2_dir_check(&dip->i_inode, name, NULL);
611 switch (error) { 616 switch (error) {
612 case -ENOENT: 617 case -ENOENT:
613 error = 0; 618 error = 0;
614 break; 619 break;
615 case 0: 620 case 0:
616 return -EEXIST; 621 return -EEXIST;
617 default: 622 default:
618 return error; 623 return error;
619 } 624 }
620 625
621 if (dip->i_di.di_entries == (u32)-1) 626 if (dip->i_di.di_entries == (u32)-1)
622 return -EFBIG; 627 return -EFBIG;
623 if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1) 628 if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
624 return -EMLINK; 629 return -EMLINK;
625 630
626 return 0; 631 return 0;
627 } 632 }
628 633
629 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode, 634 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
630 unsigned int *uid, unsigned int *gid) 635 unsigned int *uid, unsigned int *gid)
631 { 636 {
632 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir && 637 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
633 (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) { 638 (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
634 if (S_ISDIR(*mode)) 639 if (S_ISDIR(*mode))
635 *mode |= S_ISUID; 640 *mode |= S_ISUID;
636 else if (dip->i_inode.i_uid != current->fsuid) 641 else if (dip->i_inode.i_uid != current->fsuid)
637 *mode &= ~07111; 642 *mode &= ~07111;
638 *uid = dip->i_inode.i_uid; 643 *uid = dip->i_inode.i_uid;
639 } else 644 } else
640 *uid = current->fsuid; 645 *uid = current->fsuid;
641 646
642 if (dip->i_inode.i_mode & S_ISGID) { 647 if (dip->i_inode.i_mode & S_ISGID) {
643 if (S_ISDIR(*mode)) 648 if (S_ISDIR(*mode))
644 *mode |= S_ISGID; 649 *mode |= S_ISGID;
645 *gid = dip->i_inode.i_gid; 650 *gid = dip->i_inode.i_gid;
646 } else 651 } else
647 *gid = current->fsgid; 652 *gid = current->fsgid;
648 } 653 }
649 654
650 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation) 655 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
651 { 656 {
652 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 657 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
653 int error; 658 int error;
654 659
655 gfs2_alloc_get(dip); 660 gfs2_alloc_get(dip);
656 661
657 dip->i_alloc.al_requested = RES_DINODE; 662 dip->i_alloc.al_requested = RES_DINODE;
658 error = gfs2_inplace_reserve(dip); 663 error = gfs2_inplace_reserve(dip);
659 if (error) 664 if (error)
660 goto out; 665 goto out;
661 666
662 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0); 667 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
663 if (error) 668 if (error)
664 goto out_ipreserv; 669 goto out_ipreserv;
665 670
666 *no_addr = gfs2_alloc_di(dip, generation); 671 *no_addr = gfs2_alloc_di(dip, generation);
667 672
668 gfs2_trans_end(sdp); 673 gfs2_trans_end(sdp);
669 674
670 out_ipreserv: 675 out_ipreserv:
671 gfs2_inplace_release(dip); 676 gfs2_inplace_release(dip);
672 out: 677 out:
673 gfs2_alloc_put(dip); 678 gfs2_alloc_put(dip);
674 return error; 679 return error;
675 } 680 }
676 681
677 /** 682 /**
678 * init_dinode - Fill in a new dinode structure 683 * init_dinode - Fill in a new dinode structure
679 * @dip: the directory this inode is being created in 684 * @dip: the directory this inode is being created in
680 * @gl: The glock covering the new inode 685 * @gl: The glock covering the new inode
681 * @inum: the inode number 686 * @inum: the inode number
682 * @mode: the file permissions 687 * @mode: the file permissions
683 * @uid: 688 * @uid:
684 * @gid: 689 * @gid:
685 * 690 *
686 */ 691 */
687 692
688 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 693 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
689 const struct gfs2_inum_host *inum, unsigned int mode, 694 const struct gfs2_inum_host *inum, unsigned int mode,
690 unsigned int uid, unsigned int gid, 695 unsigned int uid, unsigned int gid,
691 const u64 *generation, dev_t dev) 696 const u64 *generation, dev_t dev, struct buffer_head **bhp)
692 { 697 {
693 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 698 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
694 struct gfs2_dinode *di; 699 struct gfs2_dinode *di;
695 struct buffer_head *dibh; 700 struct buffer_head *dibh;
696 struct timespec tv = CURRENT_TIME; 701 struct timespec tv = CURRENT_TIME;
697 702
698 dibh = gfs2_meta_new(gl, inum->no_addr); 703 dibh = gfs2_meta_new(gl, inum->no_addr);
699 gfs2_trans_add_bh(gl, dibh, 1); 704 gfs2_trans_add_bh(gl, dibh, 1);
700 gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI); 705 gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
701 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 706 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
702 di = (struct gfs2_dinode *)dibh->b_data; 707 di = (struct gfs2_dinode *)dibh->b_data;
703 708
704 di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino); 709 di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
705 di->di_num.no_addr = cpu_to_be64(inum->no_addr); 710 di->di_num.no_addr = cpu_to_be64(inum->no_addr);
706 di->di_mode = cpu_to_be32(mode); 711 di->di_mode = cpu_to_be32(mode);
707 di->di_uid = cpu_to_be32(uid); 712 di->di_uid = cpu_to_be32(uid);
708 di->di_gid = cpu_to_be32(gid); 713 di->di_gid = cpu_to_be32(gid);
709 di->di_nlink = 0; 714 di->di_nlink = 0;
710 di->di_size = 0; 715 di->di_size = 0;
711 di->di_blocks = cpu_to_be64(1); 716 di->di_blocks = cpu_to_be64(1);
712 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec); 717 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
713 di->di_major = cpu_to_be32(MAJOR(dev)); 718 di->di_major = cpu_to_be32(MAJOR(dev));
714 di->di_minor = cpu_to_be32(MINOR(dev)); 719 di->di_minor = cpu_to_be32(MINOR(dev));
715 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr); 720 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
716 di->di_generation = cpu_to_be64(*generation); 721 di->di_generation = cpu_to_be64(*generation);
717 di->di_flags = 0; 722 di->di_flags = 0;
718 723
719 if (S_ISREG(mode)) { 724 if (S_ISREG(mode)) {
720 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) || 725 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
721 gfs2_tune_get(sdp, gt_new_files_jdata)) 726 gfs2_tune_get(sdp, gt_new_files_jdata))
722 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA); 727 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
723 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) || 728 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
724 gfs2_tune_get(sdp, gt_new_files_directio)) 729 gfs2_tune_get(sdp, gt_new_files_directio))
725 di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO); 730 di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
726 } else if (S_ISDIR(mode)) { 731 } else if (S_ISDIR(mode)) {
727 di->di_flags |= cpu_to_be32(dip->i_di.di_flags & 732 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
728 GFS2_DIF_INHERIT_DIRECTIO); 733 GFS2_DIF_INHERIT_DIRECTIO);
729 di->di_flags |= cpu_to_be32(dip->i_di.di_flags & 734 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
730 GFS2_DIF_INHERIT_JDATA); 735 GFS2_DIF_INHERIT_JDATA);
731 } 736 }
732 737
733 di->__pad1 = 0; 738 di->__pad1 = 0;
734 di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0); 739 di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
735 di->di_height = 0; 740 di->di_height = 0;
736 di->__pad2 = 0; 741 di->__pad2 = 0;
737 di->__pad3 = 0; 742 di->__pad3 = 0;
738 di->di_depth = 0; 743 di->di_depth = 0;
739 di->di_entries = 0; 744 di->di_entries = 0;
740 memset(&di->__pad4, 0, sizeof(di->__pad4)); 745 memset(&di->__pad4, 0, sizeof(di->__pad4));
741 di->di_eattr = 0; 746 di->di_eattr = 0;
742 di->di_atime_nsec = cpu_to_be32(tv.tv_nsec); 747 di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
743 di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec); 748 di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
744 di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec); 749 di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
745 memset(&di->di_reserved, 0, sizeof(di->di_reserved)); 750 memset(&di->di_reserved, 0, sizeof(di->di_reserved));
751
752 set_buffer_uptodate(dibh);
746 753
747 brelse(dibh); 754 *bhp = dibh;
748 } 755 }
749 756
750 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 757 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
751 unsigned int mode, const struct gfs2_inum_host *inum, 758 unsigned int mode, const struct gfs2_inum_host *inum,
752 const u64 *generation, dev_t dev) 759 const u64 *generation, dev_t dev, struct buffer_head **bhp)
753 { 760 {
754 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 761 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
755 unsigned int uid, gid; 762 unsigned int uid, gid;
756 int error; 763 int error;
757 764
758 munge_mode_uid_gid(dip, &mode, &uid, &gid); 765 munge_mode_uid_gid(dip, &mode, &uid, &gid);
759 gfs2_alloc_get(dip); 766 gfs2_alloc_get(dip);
760 767
761 error = gfs2_quota_lock(dip, uid, gid); 768 error = gfs2_quota_lock(dip, uid, gid);
762 if (error) 769 if (error)
763 goto out; 770 goto out;
764 771
765 error = gfs2_quota_check(dip, uid, gid); 772 error = gfs2_quota_check(dip, uid, gid);
766 if (error) 773 if (error)
767 goto out_quota; 774 goto out_quota;
768 775
769 error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0); 776 error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
770 if (error) 777 if (error)
771 goto out_quota; 778 goto out_quota;
772 779
773 init_dinode(dip, gl, inum, mode, uid, gid, generation, dev); 780 init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp);
774 gfs2_quota_change(dip, +1, uid, gid); 781 gfs2_quota_change(dip, +1, uid, gid);
775 gfs2_trans_end(sdp); 782 gfs2_trans_end(sdp);
776 783
777 out_quota: 784 out_quota:
778 gfs2_quota_unlock(dip); 785 gfs2_quota_unlock(dip);
779 out: 786 out:
780 gfs2_alloc_put(dip); 787 gfs2_alloc_put(dip);
781 return error; 788 return error;
782 } 789 }
783 790
784 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name, 791 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
785 struct gfs2_inode *ip) 792 struct gfs2_inode *ip)
786 { 793 {
787 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 794 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
788 struct gfs2_alloc *al; 795 struct gfs2_alloc *al;
789 int alloc_required; 796 int alloc_required;
790 struct buffer_head *dibh; 797 struct buffer_head *dibh;
791 int error; 798 int error;
792 799
793 al = gfs2_alloc_get(dip); 800 al = gfs2_alloc_get(dip);
794 801
795 error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 802 error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
796 if (error) 803 if (error)
797 goto fail; 804 goto fail;
798 805
799 error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name); 806 error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
800 if (alloc_required < 0) 807 if (alloc_required < 0)
801 goto fail; 808 goto fail;
802 if (alloc_required) { 809 if (alloc_required) {
803 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid); 810 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
804 if (error) 811 if (error)
805 goto fail_quota_locks; 812 goto fail_quota_locks;
806 813
807 al->al_requested = sdp->sd_max_dirres; 814 al->al_requested = sdp->sd_max_dirres;
808 815
809 error = gfs2_inplace_reserve(dip); 816 error = gfs2_inplace_reserve(dip);
810 if (error) 817 if (error)
811 goto fail_quota_locks; 818 goto fail_quota_locks;
812 819
813 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 820 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
814 al->al_rgd->rd_length + 821 al->al_rgd->rd_length +
815 2 * RES_DINODE + 822 2 * RES_DINODE +
816 RES_STATFS + RES_QUOTA, 0); 823 RES_STATFS + RES_QUOTA, 0);
817 if (error) 824 if (error)
818 goto fail_ipreserv; 825 goto fail_ipreserv;
819 } else { 826 } else {
820 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0); 827 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
821 if (error) 828 if (error)
822 goto fail_quota_locks; 829 goto fail_quota_locks;
823 } 830 }
824 831
825 error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode)); 832 error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
826 if (error) 833 if (error)
827 goto fail_end_trans; 834 goto fail_end_trans;
828 835
829 error = gfs2_meta_inode_buffer(ip, &dibh); 836 error = gfs2_meta_inode_buffer(ip, &dibh);
830 if (error) 837 if (error)
831 goto fail_end_trans; 838 goto fail_end_trans;
832 ip->i_inode.i_nlink = 1; 839 ip->i_inode.i_nlink = 1;
833 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 840 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
834 gfs2_dinode_out(ip, dibh->b_data); 841 gfs2_dinode_out(ip, dibh->b_data);
835 brelse(dibh); 842 brelse(dibh);
836 return 0; 843 return 0;
837 844
838 fail_end_trans: 845 fail_end_trans:
839 gfs2_trans_end(sdp); 846 gfs2_trans_end(sdp);
840 847
841 fail_ipreserv: 848 fail_ipreserv:
842 if (dip->i_alloc.al_rgd) 849 if (dip->i_alloc.al_rgd)
843 gfs2_inplace_release(dip); 850 gfs2_inplace_release(dip);
844 851
845 fail_quota_locks: 852 fail_quota_locks:
846 gfs2_quota_unlock(dip); 853 gfs2_quota_unlock(dip);
847 854
848 fail: 855 fail:
849 gfs2_alloc_put(dip); 856 gfs2_alloc_put(dip);
850 return error; 857 return error;
851 } 858 }
852 859
853 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip) 860 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
854 { 861 {
855 int err; 862 int err;
856 size_t len; 863 size_t len;
857 void *value; 864 void *value;
858 char *name; 865 char *name;
859 struct gfs2_ea_request er; 866 struct gfs2_ea_request er;
860 867
861 err = security_inode_init_security(&ip->i_inode, &dip->i_inode, 868 err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
862 &name, &value, &len); 869 &name, &value, &len);
863 870
864 if (err) { 871 if (err) {
865 if (err == -EOPNOTSUPP) 872 if (err == -EOPNOTSUPP)
866 return 0; 873 return 0;
867 return err; 874 return err;
868 } 875 }
869 876
870 memset(&er, 0, sizeof(struct gfs2_ea_request)); 877 memset(&er, 0, sizeof(struct gfs2_ea_request));
871 878
872 er.er_type = GFS2_EATYPE_SECURITY; 879 er.er_type = GFS2_EATYPE_SECURITY;
873 er.er_name = name; 880 er.er_name = name;
874 er.er_data = value; 881 er.er_data = value;
875 er.er_name_len = strlen(name); 882 er.er_name_len = strlen(name);
876 er.er_data_len = len; 883 er.er_data_len = len;
877 884
878 err = gfs2_ea_set_i(ip, &er); 885 err = gfs2_ea_set_i(ip, &er);
879 886
880 kfree(value); 887 kfree(value);
881 kfree(name); 888 kfree(name);
882 889
883 return err; 890 return err;
884 } 891 }
885 892
886 /** 893 /**
887 * gfs2_createi - Create a new inode 894 * gfs2_createi - Create a new inode
888 * @ghs: An array of two holders 895 * @ghs: An array of two holders
889 * @name: The name of the new file 896 * @name: The name of the new file
890 * @mode: the permissions on the new inode 897 * @mode: the permissions on the new inode
891 * 898 *
892 * @ghs[0] is an initialized holder for the directory 899 * @ghs[0] is an initialized holder for the directory
893 * @ghs[1] is the holder for the inode lock 900 * @ghs[1] is the holder for the inode lock
894 * 901 *
895 * If the return value is not NULL, the glocks on both the directory and the new 902 * If the return value is not NULL, the glocks on both the directory and the new
896 * file are held. A transaction has been started and an inplace reservation 903 * file are held. A transaction has been started and an inplace reservation
897 * is held, as well. 904 * is held, as well.
898 * 905 *
899 * Returns: An inode 906 * Returns: An inode
900 */ 907 */
901 908
902 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name, 909 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
903 unsigned int mode, dev_t dev) 910 unsigned int mode, dev_t dev)
904 { 911 {
905 struct inode *inode = NULL; 912 struct inode *inode = NULL;
906 struct gfs2_inode *dip = ghs->gh_gl->gl_object; 913 struct gfs2_inode *dip = ghs->gh_gl->gl_object;
907 struct inode *dir = &dip->i_inode; 914 struct inode *dir = &dip->i_inode;
908 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 915 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
909 struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 }; 916 struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
910 int error; 917 int error;
911 u64 generation; 918 u64 generation;
919 struct buffer_head *bh=NULL;
912 920
913 if (!name->len || name->len > GFS2_FNAMESIZE) 921 if (!name->len || name->len > GFS2_FNAMESIZE)
914 return ERR_PTR(-ENAMETOOLONG); 922 return ERR_PTR(-ENAMETOOLONG);
915 923
916 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs); 924 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
917 error = gfs2_glock_nq(ghs); 925 error = gfs2_glock_nq(ghs);
918 if (error) 926 if (error)
919 goto fail; 927 goto fail;
920 928
921 error = create_ok(dip, name, mode); 929 error = create_ok(dip, name, mode);
922 if (error) 930 if (error)
923 goto fail_gunlock; 931 goto fail_gunlock;
924 932
925 error = pick_formal_ino(sdp, &inum.no_formal_ino); 933 error = pick_formal_ino(sdp, &inum.no_formal_ino);
926 if (error) 934 if (error)
927 goto fail_gunlock; 935 goto fail_gunlock;
928 936
929 error = alloc_dinode(dip, &inum.no_addr, &generation); 937 error = alloc_dinode(dip, &inum.no_addr, &generation);
930 if (error) 938 if (error)
931 goto fail_gunlock; 939 goto fail_gunlock;
932 940
933 error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops, 941 error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
934 LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1); 942 LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
935 if (error) 943 if (error)
936 goto fail_gunlock; 944 goto fail_gunlock;
937 945
938 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev); 946 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);
939 if (error) 947 if (error)
940 goto fail_gunlock2; 948 goto fail_gunlock2;
941 949
942 inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), 950 inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode),
943 inum.no_addr, 951 inum.no_addr,
944 inum.no_formal_ino); 952 inum.no_formal_ino);
945 if (IS_ERR(inode)) 953 if (IS_ERR(inode))
946 goto fail_gunlock2; 954 goto fail_gunlock2;
955
956 gfs2_inode_bh(GFS2_I(inode), bh);
947 957
948 error = gfs2_inode_refresh(GFS2_I(inode)); 958 error = gfs2_inode_refresh(GFS2_I(inode));
949 if (error) 959 if (error)
950 goto fail_gunlock2; 960 goto fail_gunlock2;
951 961
952 error = gfs2_acl_create(dip, GFS2_I(inode)); 962 error = gfs2_acl_create(dip, GFS2_I(inode));
953 if (error) 963 if (error)
954 goto fail_gunlock2; 964 goto fail_gunlock2;
955 965
956 error = gfs2_security_init(dip, GFS2_I(inode)); 966 error = gfs2_security_init(dip, GFS2_I(inode));
957 if (error) 967 if (error)
958 goto fail_gunlock2; 968 goto fail_gunlock2;
959 969
960 error = link_dinode(dip, name, GFS2_I(inode)); 970 error = link_dinode(dip, name, GFS2_I(inode));
961 if (error) 971 if (error)
962 goto fail_gunlock2; 972 goto fail_gunlock2;
963 973
964 if (!inode) 974 if (!inode)
965 return ERR_PTR(-ENOMEM); 975 return ERR_PTR(-ENOMEM);
966 return inode; 976 return inode;
967 977
968 fail_gunlock2: 978 fail_gunlock2:
969 gfs2_glock_dq_uninit(ghs + 1); 979 gfs2_glock_dq_uninit(ghs + 1);
970 if (inode) 980 if (inode)
971 iput(inode); 981 iput(inode);
972 fail_gunlock: 982 fail_gunlock:
973 gfs2_glock_dq(ghs); 983 gfs2_glock_dq(ghs);
974 fail: 984 fail:
975 return ERR_PTR(error); 985 return ERR_PTR(error);
976 } 986 }
977 987
978 /** 988 /**
979 * gfs2_rmdiri - Remove a directory 989 * gfs2_rmdiri - Remove a directory
980 * @dip: The parent directory of the directory to be removed 990 * @dip: The parent directory of the directory to be removed
981 * @name: The name of the directory to be removed 991 * @name: The name of the directory to be removed
982 * @ip: The GFS2 inode of the directory to be removed 992 * @ip: The GFS2 inode of the directory to be removed
983 * 993 *
984 * Assumes Glocks on dip and ip are held 994 * Assumes Glocks on dip and ip are held
985 * 995 *
986 * Returns: errno 996 * Returns: errno
987 */ 997 */
988 998
989 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name, 999 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
990 struct gfs2_inode *ip) 1000 struct gfs2_inode *ip)
991 { 1001 {
992 struct qstr dotname; 1002 struct qstr dotname;
993 int error; 1003 int error;
994 1004
995 if (ip->i_di.di_entries != 2) { 1005 if (ip->i_di.di_entries != 2) {
996 if (gfs2_consist_inode(ip)) 1006 if (gfs2_consist_inode(ip))
997 gfs2_dinode_print(ip); 1007 gfs2_dinode_print(ip);
998 return -EIO; 1008 return -EIO;
999 } 1009 }
1000 1010
1001 error = gfs2_dir_del(dip, name); 1011 error = gfs2_dir_del(dip, name);
1002 if (error) 1012 if (error)
1003 return error; 1013 return error;
1004 1014
1005 error = gfs2_change_nlink(dip, -1); 1015 error = gfs2_change_nlink(dip, -1);
1006 if (error) 1016 if (error)
1007 return error; 1017 return error;
1008 1018
1009 gfs2_str2qstr(&dotname, "."); 1019 gfs2_str2qstr(&dotname, ".");
1010 error = gfs2_dir_del(ip, &dotname); 1020 error = gfs2_dir_del(ip, &dotname);
1011 if (error) 1021 if (error)
1012 return error; 1022 return error;
1013 1023
1014 gfs2_str2qstr(&dotname, ".."); 1024 gfs2_str2qstr(&dotname, "..");
1015 error = gfs2_dir_del(ip, &dotname); 1025 error = gfs2_dir_del(ip, &dotname);
1016 if (error) 1026 if (error)
1017 return error; 1027 return error;
1018 1028
1019 /* It looks odd, but it really should be done twice */ 1029 /* It looks odd, but it really should be done twice */
1020 error = gfs2_change_nlink(ip, -1); 1030 error = gfs2_change_nlink(ip, -1);
1021 if (error) 1031 if (error)
1022 return error; 1032 return error;
1023 1033
1024 error = gfs2_change_nlink(ip, -1); 1034 error = gfs2_change_nlink(ip, -1);
1025 if (error) 1035 if (error)
1026 return error; 1036 return error;
1027 1037
1028 return error; 1038 return error;
1029 } 1039 }
1030 1040
1031 /* 1041 /*
1032 * gfs2_unlink_ok - check to see that a inode is still in a directory 1042 * gfs2_unlink_ok - check to see that a inode is still in a directory
1033 * @dip: the directory 1043 * @dip: the directory
1034 * @name: the name of the file 1044 * @name: the name of the file
1035 * @ip: the inode 1045 * @ip: the inode
1036 * 1046 *
1037 * Assumes that the lock on (at least) @dip is held. 1047 * Assumes that the lock on (at least) @dip is held.
1038 * 1048 *
1039 * Returns: 0 if the parent/child relationship is correct, errno if it isn't 1049 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
1040 */ 1050 */
1041 1051
1042 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name, 1052 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
1043 const struct gfs2_inode *ip) 1053 const struct gfs2_inode *ip)
1044 { 1054 {
1045 int error; 1055 int error;
1046 1056
1047 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode)) 1057 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
1048 return -EPERM; 1058 return -EPERM;
1049 1059
1050 if ((dip->i_inode.i_mode & S_ISVTX) && 1060 if ((dip->i_inode.i_mode & S_ISVTX) &&
1051 dip->i_inode.i_uid != current->fsuid && 1061 dip->i_inode.i_uid != current->fsuid &&
1052 ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER)) 1062 ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER))
1053 return -EPERM; 1063 return -EPERM;
1054 1064
1055 if (IS_APPEND(&dip->i_inode)) 1065 if (IS_APPEND(&dip->i_inode))
1056 return -EPERM; 1066 return -EPERM;
1057 1067
1058 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL); 1068 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
1059 if (error) 1069 if (error)
1060 return error; 1070 return error;
1061 1071
1062 error = gfs2_dir_check(&dip->i_inode, name, ip); 1072 error = gfs2_dir_check(&dip->i_inode, name, ip);
1063 if (error) 1073 if (error)
1064 return error; 1074 return error;
1065 1075
1066 return 0; 1076 return 0;
1067 } 1077 }
1068 1078
1069 /* 1079 /*
1070 * gfs2_ok_to_move - check if it's ok to move a directory to another directory 1080 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1071 * @this: move this 1081 * @this: move this
1072 * @to: to here 1082 * @to: to here
1073 * 1083 *
1074 * Follow @to back to the root and make sure we don't encounter @this 1084 * Follow @to back to the root and make sure we don't encounter @this
1075 * Assumes we already hold the rename lock. 1085 * Assumes we already hold the rename lock.
1076 * 1086 *
1077 * Returns: errno 1087 * Returns: errno
1078 */ 1088 */
1079 1089
1080 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to) 1090 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1081 { 1091 {
1082 struct inode *dir = &to->i_inode; 1092 struct inode *dir = &to->i_inode;
1083 struct super_block *sb = dir->i_sb; 1093 struct super_block *sb = dir->i_sb;
1084 struct inode *tmp; 1094 struct inode *tmp;
1085 struct qstr dotdot; 1095 struct qstr dotdot;
1086 int error = 0; 1096 int error = 0;
1087 1097
1088 gfs2_str2qstr(&dotdot, ".."); 1098 gfs2_str2qstr(&dotdot, "..");
1089 1099
1090 igrab(dir); 1100 igrab(dir);
1091 1101
1092 for (;;) { 1102 for (;;) {
1093 if (dir == &this->i_inode) { 1103 if (dir == &this->i_inode) {
1094 error = -EINVAL; 1104 error = -EINVAL;
1095 break; 1105 break;
1096 } 1106 }
1097 if (dir == sb->s_root->d_inode) { 1107 if (dir == sb->s_root->d_inode) {
1098 error = 0; 1108 error = 0;
1099 break; 1109 break;
1100 } 1110 }
1101 1111
1102 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL); 1112 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
1103 if (IS_ERR(tmp)) { 1113 if (IS_ERR(tmp)) {
1104 error = PTR_ERR(tmp); 1114 error = PTR_ERR(tmp);
1105 break; 1115 break;
1106 } 1116 }
1107 1117
1108 iput(dir); 1118 iput(dir);
1109 dir = tmp; 1119 dir = tmp;
1110 } 1120 }
1111 1121
1112 iput(dir); 1122 iput(dir);
1113 1123
1114 return error; 1124 return error;
1115 } 1125 }
1116 1126
1117 /** 1127 /**
1118 * gfs2_readlinki - return the contents of a symlink 1128 * gfs2_readlinki - return the contents of a symlink
1119 * @ip: the symlink's inode 1129 * @ip: the symlink's inode
1120 * @buf: a pointer to the buffer to be filled 1130 * @buf: a pointer to the buffer to be filled
1121 * @len: a pointer to the length of @buf 1131 * @len: a pointer to the length of @buf
1122 * 1132 *
1123 * If @buf is too small, a piece of memory is kmalloc()ed and needs 1133 * If @buf is too small, a piece of memory is kmalloc()ed and needs
1124 * to be freed by the caller. 1134 * to be freed by the caller.
1125 * 1135 *
1126 * Returns: errno 1136 * Returns: errno
1127 */ 1137 */
1128 1138
1129 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len) 1139 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
1130 { 1140 {
1131 struct gfs2_holder i_gh; 1141 struct gfs2_holder i_gh;
1132 struct buffer_head *dibh; 1142 struct buffer_head *dibh;
1133 unsigned int x; 1143 unsigned int x;
1134 int error; 1144 int error;
1135 1145
1136 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh); 1146 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
1137 error = gfs2_glock_nq_atime(&i_gh); 1147 error = gfs2_glock_nq_atime(&i_gh);
1138 if (error) { 1148 if (error) {
1139 gfs2_holder_uninit(&i_gh); 1149 gfs2_holder_uninit(&i_gh);
1140 return error; 1150 return error;
1141 } 1151 }
1142 1152
1143 if (!ip->i_di.di_size) { 1153 if (!ip->i_di.di_size) {
1144 gfs2_consist_inode(ip); 1154 gfs2_consist_inode(ip);
1145 error = -EIO; 1155 error = -EIO;
1146 goto out; 1156 goto out;
1147 } 1157 }
1148 1158
1149 error = gfs2_meta_inode_buffer(ip, &dibh); 1159 error = gfs2_meta_inode_buffer(ip, &dibh);
1150 if (error) 1160 if (error)
1151 goto out; 1161 goto out;
1152 1162
1153 x = ip->i_di.di_size + 1; 1163 x = ip->i_di.di_size + 1;
1154 if (x > *len) { 1164 if (x > *len) {
1155 *buf = kmalloc(x, GFP_KERNEL); 1165 *buf = kmalloc(x, GFP_KERNEL);
1156 if (!*buf) { 1166 if (!*buf) {
1157 error = -ENOMEM; 1167 error = -ENOMEM;
1158 goto out_brelse; 1168 goto out_brelse;
1159 } 1169 }
1160 } 1170 }
1161 1171
1162 memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x); 1172 memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
1163 *len = x; 1173 *len = x;
1164 1174
1165 out_brelse: 1175 out_brelse:
1166 brelse(dibh); 1176 brelse(dibh);
1167 out: 1177 out:
1168 gfs2_glock_dq_uninit(&i_gh); 1178 gfs2_glock_dq_uninit(&i_gh);
1169 return error; 1179 return error;
1170 } 1180 }
1171 1181
1172 /** 1182 /**
1173 * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and 1183 * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and
1174 * conditionally update the inode's atime 1184 * conditionally update the inode's atime
1175 * @gh: the holder to acquire 1185 * @gh: the holder to acquire
1176 * 1186 *
1177 * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap 1187 * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap
1178 * Update if the difference between the current time and the inode's current 1188 * Update if the difference between the current time and the inode's current
1179 * atime is greater than an interval specified at mount. 1189 * atime is greater than an interval specified at mount.
1180 * 1190 *
1181 * Returns: errno 1191 * Returns: errno
1182 */ 1192 */
1183 1193
1184 int gfs2_glock_nq_atime(struct gfs2_holder *gh) 1194 int gfs2_glock_nq_atime(struct gfs2_holder *gh)
1185 { 1195 {
1186 struct gfs2_glock *gl = gh->gh_gl; 1196 struct gfs2_glock *gl = gh->gh_gl;
1187 struct gfs2_sbd *sdp = gl->gl_sbd; 1197 struct gfs2_sbd *sdp = gl->gl_sbd;
1188 struct gfs2_inode *ip = gl->gl_object; 1198 struct gfs2_inode *ip = gl->gl_object;
1189 s64 quantum = gfs2_tune_get(sdp, gt_atime_quantum); 1199 s64 quantum = gfs2_tune_get(sdp, gt_atime_quantum);
1190 unsigned int state; 1200 unsigned int state;
1191 int flags; 1201 int flags;
1192 int error; 1202 int error;
1193 struct timespec tv = CURRENT_TIME; 1203 struct timespec tv = CURRENT_TIME;
1194 1204
1195 if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) || 1205 if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) ||
1196 gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) || 1206 gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) ||
1197 gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops)) 1207 gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops))
1198 return -EINVAL; 1208 return -EINVAL;
1199 1209
1200 state = gh->gh_state; 1210 state = gh->gh_state;
1201 flags = gh->gh_flags; 1211 flags = gh->gh_flags;
1202 1212
1203 error = gfs2_glock_nq(gh); 1213 error = gfs2_glock_nq(gh);
1204 if (error) 1214 if (error)
1205 return error; 1215 return error;
1206 1216
1207 if (test_bit(SDF_NOATIME, &sdp->sd_flags) || 1217 if (test_bit(SDF_NOATIME, &sdp->sd_flags) ||
1208 (sdp->sd_vfs->s_flags & MS_RDONLY)) 1218 (sdp->sd_vfs->s_flags & MS_RDONLY))
1209 return 0; 1219 return 0;
1210 1220
1211 if (tv.tv_sec - ip->i_inode.i_atime.tv_sec >= quantum) { 1221 if (tv.tv_sec - ip->i_inode.i_atime.tv_sec >= quantum) {
1212 gfs2_glock_dq(gh); 1222 gfs2_glock_dq(gh);
1213 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY, 1223 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY,
1214 gh); 1224 gh);
1215 error = gfs2_glock_nq(gh); 1225 error = gfs2_glock_nq(gh);
1216 if (error) 1226 if (error)
1217 return error; 1227 return error;
1218 1228
1219 /* Verify that atime hasn't been updated while we were 1229 /* Verify that atime hasn't been updated while we were
1220 trying to get exclusive lock. */ 1230 trying to get exclusive lock. */
1221 1231
1222 tv = CURRENT_TIME; 1232 tv = CURRENT_TIME;
1223 if (tv.tv_sec - ip->i_inode.i_atime.tv_sec >= quantum) { 1233 if (tv.tv_sec - ip->i_inode.i_atime.tv_sec >= quantum) {
1224 struct buffer_head *dibh; 1234 struct buffer_head *dibh;
1225 struct gfs2_dinode *di; 1235 struct gfs2_dinode *di;
1226 1236
1227 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 1237 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1228 if (error == -EROFS) 1238 if (error == -EROFS)
1229 return 0; 1239 return 0;
1230 if (error) 1240 if (error)
1231 goto fail; 1241 goto fail;
1232 1242
1233 error = gfs2_meta_inode_buffer(ip, &dibh); 1243 error = gfs2_meta_inode_buffer(ip, &dibh);
1234 if (error) 1244 if (error)
1235 goto fail_end_trans; 1245 goto fail_end_trans;
1236 1246
1237 ip->i_inode.i_atime = tv; 1247 ip->i_inode.i_atime = tv;
1238 1248
1239 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1249 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1240 di = (struct gfs2_dinode *)dibh->b_data; 1250 di = (struct gfs2_dinode *)dibh->b_data;
1241 di->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 1251 di->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1242 di->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 1252 di->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
1243 brelse(dibh); 1253 brelse(dibh);
1244 1254
1245 gfs2_trans_end(sdp); 1255 gfs2_trans_end(sdp);
1246 } 1256 }
1247 1257
1248 /* If someone else has asked for the glock, 1258 /* If someone else has asked for the glock,
1249 unlock and let them have it. Then reacquire 1259 unlock and let them have it. Then reacquire
1250 in the original state. */ 1260 in the original state. */
1251 if (gfs2_glock_is_blocking(gl)) { 1261 if (gfs2_glock_is_blocking(gl)) {
1252 gfs2_glock_dq(gh); 1262 gfs2_glock_dq(gh);
1253 gfs2_holder_reinit(state, flags, gh); 1263 gfs2_holder_reinit(state, flags, gh);
1254 return gfs2_glock_nq(gh); 1264 return gfs2_glock_nq(gh);
1255 } 1265 }
1256 } 1266 }
1257 1267
1258 return 0; 1268 return 0;
1259 1269
1260 fail_end_trans: 1270 fail_end_trans:
1261 gfs2_trans_end(sdp); 1271 gfs2_trans_end(sdp);
1262 fail: 1272 fail:
1263 gfs2_glock_dq(gh); 1273 gfs2_glock_dq(gh);
1264 return error; 1274 return error;
1265 } 1275 }
1266 1276
1267 static int 1277 static int
1268 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 1278 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1269 { 1279 {
1270 struct buffer_head *dibh; 1280 struct buffer_head *dibh;
1271 int error; 1281 int error;
1272 1282
1273 error = gfs2_meta_inode_buffer(ip, &dibh); 1283 error = gfs2_meta_inode_buffer(ip, &dibh);
1274 if (!error) { 1284 if (!error) {
1275 error = inode_setattr(&ip->i_inode, attr); 1285 error = inode_setattr(&ip->i_inode, attr);
1276 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error); 1286 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1277 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1287 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1278 gfs2_dinode_out(ip, dibh->b_data); 1288 gfs2_dinode_out(ip, dibh->b_data);
1279 brelse(dibh); 1289 brelse(dibh);
1280 } 1290 }
1281 return error; 1291 return error;
1282 } 1292 }
1283 1293
1284 /** 1294 /**
1285 * gfs2_setattr_simple - 1295 * gfs2_setattr_simple -
1286 * @ip: 1296 * @ip:
1287 * @attr: 1297 * @attr:
1288 * 1298 *
1289 * Called with a reference on the vnode. 1299 * Called with a reference on the vnode.
1290 * 1300 *
1291 * Returns: errno 1301 * Returns: errno
1292 */ 1302 */
1293 1303
1294 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 1304 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1295 { 1305 {
1296 int error; 1306 int error;
1297 1307
1298 if (current->journal_info) 1308 if (current->journal_info)
1299 return __gfs2_setattr_simple(ip, attr); 1309 return __gfs2_setattr_simple(ip, attr);
1300 1310
1301 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0); 1311 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
1302 if (error) 1312 if (error)
1303 return error; 1313 return error;
1304 1314
1305 error = __gfs2_setattr_simple(ip, attr); 1315 error = __gfs2_setattr_simple(ip, attr);
1306 gfs2_trans_end(GFS2_SB(&ip->i_inode)); 1316 gfs2_trans_end(GFS2_SB(&ip->i_inode));
1307 return error; 1317 return error;
1308 } 1318 }
1309 1319
1310 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf) 1320 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
1311 { 1321 {
1312 const struct gfs2_dinode_host *di = &ip->i_di; 1322 const struct gfs2_dinode_host *di = &ip->i_di;
1313 struct gfs2_dinode *str = buf; 1323 struct gfs2_dinode *str = buf;
1314 1324
1315 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 1325 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
1316 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); 1326 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
1317 str->di_header.__pad0 = 0; 1327 str->di_header.__pad0 = 0;
1318 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); 1328 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
1319 str->di_header.__pad1 = 0; 1329 str->di_header.__pad1 = 0;
1320 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr); 1330 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
1321 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino); 1331 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
1322 str->di_mode = cpu_to_be32(ip->i_inode.i_mode); 1332 str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
1323 str->di_uid = cpu_to_be32(ip->i_inode.i_uid); 1333 str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
1324 str->di_gid = cpu_to_be32(ip->i_inode.i_gid); 1334 str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
1325 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); 1335 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
1326 str->di_size = cpu_to_be64(di->di_size); 1336 str->di_size = cpu_to_be64(di->di_size);
1327 str->di_blocks = cpu_to_be64(di->di_blocks); 1337 str->di_blocks = cpu_to_be64(di->di_blocks);
1328 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 1338 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1329 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec); 1339 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
1330 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec); 1340 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
1331 1341
1332 str->di_goal_meta = cpu_to_be64(di->di_goal_meta); 1342 str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
1333 str->di_goal_data = cpu_to_be64(di->di_goal_data); 1343 str->di_goal_data = cpu_to_be64(di->di_goal_data);
1334 str->di_generation = cpu_to_be64(di->di_generation); 1344 str->di_generation = cpu_to_be64(di->di_generation);
1335 1345
1336 str->di_flags = cpu_to_be32(di->di_flags); 1346 str->di_flags = cpu_to_be32(di->di_flags);
1337 str->di_height = cpu_to_be16(di->di_height); 1347 str->di_height = cpu_to_be16(di->di_height);
1338 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) && 1348 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
1339 !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ? 1349 !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
1340 GFS2_FORMAT_DE : 0); 1350 GFS2_FORMAT_DE : 0);
1341 str->di_depth = cpu_to_be16(di->di_depth); 1351 str->di_depth = cpu_to_be16(di->di_depth);
1342 str->di_entries = cpu_to_be32(di->di_entries); 1352 str->di_entries = cpu_to_be32(di->di_entries);
1343 1353
1344 str->di_eattr = cpu_to_be64(di->di_eattr); 1354 str->di_eattr = cpu_to_be64(di->di_eattr);
1345 str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 1355 str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
1346 str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec); 1356 str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
1347 str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec); 1357 str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
1348 } 1358 }
1349 1359
1350 void gfs2_dinode_print(const struct gfs2_inode *ip) 1360 void gfs2_dinode_print(const struct gfs2_inode *ip)
1351 { 1361 {
1352 const struct gfs2_dinode_host *di = &ip->i_di; 1362 const struct gfs2_dinode_host *di = &ip->i_di;
1353 1363
1354 printk(KERN_INFO " no_formal_ino = %llu\n", 1364 printk(KERN_INFO " no_formal_ino = %llu\n",
1355 (unsigned long long)ip->i_no_formal_ino); 1365 (unsigned long long)ip->i_no_formal_ino);
1356 printk(KERN_INFO " no_addr = %llu\n", 1366 printk(KERN_INFO " no_addr = %llu\n",
1357 (unsigned long long)ip->i_no_addr); 1367 (unsigned long long)ip->i_no_addr);
1358 printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size); 1368 printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size);
1359 printk(KERN_INFO " di_blocks = %llu\n", 1369 printk(KERN_INFO " di_blocks = %llu\n",
1360 (unsigned long long)di->di_blocks); 1370 (unsigned long long)di->di_blocks);
1361 printk(KERN_INFO " di_goal_meta = %llu\n", 1371 printk(KERN_INFO " di_goal_meta = %llu\n",
1362 (unsigned long long)di->di_goal_meta); 1372 (unsigned long long)di->di_goal_meta);
1363 printk(KERN_INFO " di_goal_data = %llu\n", 1373 printk(KERN_INFO " di_goal_data = %llu\n",
1364 (unsigned long long)di->di_goal_data); 1374 (unsigned long long)di->di_goal_data);
1365 printk(KERN_INFO " di_flags = 0x%.8X\n", di->di_flags); 1375 printk(KERN_INFO " di_flags = 0x%.8X\n", di->di_flags);
1366 printk(KERN_INFO " di_height = %u\n", di->di_height); 1376 printk(KERN_INFO " di_height = %u\n", di->di_height);
1367 printk(KERN_INFO " di_depth = %u\n", di->di_depth); 1377 printk(KERN_INFO " di_depth = %u\n", di->di_depth);
1368 printk(KERN_INFO " di_entries = %u\n", di->di_entries); 1378 printk(KERN_INFO " di_entries = %u\n", di->di_entries);
1369 printk(KERN_INFO " di_eattr = %llu\n", 1379 printk(KERN_INFO " di_eattr = %llu\n",
1370 (unsigned long long)di->di_eattr); 1380 (unsigned long long)di->di_eattr);
1371 } 1381 }
1372 1382
1373 1383