Eric Lee / smarc-ti-linux-kernel

3
Download as
Browse Code ยป

Commit 53dc20b9a3d928b0744dad5aee65b610de1cc85d

Authored by Xue jiufei
Committed by Linus Torvalds
1 parent 75dd112aac
Exists in ti-lsk-linux-4.1.y and in 10 other branches dlt-processor-sdk-linux-03.00.00.04, processor-sdk-linux-02.00.01, 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

ocfs2: fix the wrong directory passed to ocfs2_lookup_ino_from_name() when link file 

In ocfs2_link(), the parent directory inode passed to function
ocfs2_lookup_ino_from_name() is wrong.  Parameter dir is the parent of
new_dentry not old_dentry.  We should get old_dir from old_dentry and
lookup old_dentry in old_dir in case another node remove the old dentry.

With this change, hard linking works again, when paths are relative with
at least one subdirectory.  This is how the problem was reproducable:

  # mkdir a
  # mkdir b
  # touch a/test
  # ln a/test b/test
  ln: failed to create hard link `b/test' => `a/test': No such file or  directory

However when creating links in the same dir, it worked well.

Now the link gets created.

Fixes: 0e048316ff57 ("ocfs2: check existence of old dentry in ocfs2_link()")
Signed-off-by: joyce.xue <xuejiufei@huawei.com>
Reported-by: Szabo Aron - UBIT <aron@ubit.hu>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <jlbec@evilplan.org>
Tested-by: Aron Szabo <aron@ubit.hu>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 35 additions and 8 deletions Inline Diff

1 /* -*- mode: c; c-basic-offset: 8; -*- 1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0: 2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 * 3 *
4 * namei.c 4 * namei.c
5 * 5 *
6 * Create and rename file, directory, symlinks 6 * Create and rename file, directory, symlinks
7 * 7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 * 9 *
10 * Portions of this code from linux/fs/ext3/dir.c 10 * Portions of this code from linux/fs/ext3/dir.c
11 * 11 *
12 * Copyright (C) 1992, 1993, 1994, 1995 12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr) 13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise pascal 14 * Laboratoire MASI - Institut Blaise pascal
15 * Universite Pierre et Marie Curie (Paris VI) 15 * Universite Pierre et Marie Curie (Paris VI)
16 * 16 *
17 * from 17 * from
18 * 18 *
19 * linux/fs/minix/dir.c 19 * linux/fs/minix/dir.c
20 * 20 *
21 * Copyright (C) 1991, 1992 Linux Torvalds 21 * Copyright (C) 1991, 1992 Linux Torvalds
22 * 22 *
23 * This program is free software; you can redistribute it and/or 23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public 24 * modify it under the terms of the GNU General Public
25 * License as published by the Free Software Foundation; either 25 * License as published by the Free Software Foundation; either
26 * version 2 of the License, or (at your option) any later version. 26 * version 2 of the License, or (at your option) any later version.
27 * 27 *
28 * This program is distributed in the hope that it will be useful, 28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of 29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * General Public License for more details. 31 * General Public License for more details.
32 * 32 *
33 * You should have received a copy of the GNU General Public 33 * You should have received a copy of the GNU General Public
34 * License along with this program; if not, write to the 34 * License along with this program; if not, write to the
35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
36 * Boston, MA 021110-1307, USA. 36 * Boston, MA 021110-1307, USA.
37 */ 37 */
38 38
39 #include <linux/fs.h> 39 #include <linux/fs.h>
40 #include <linux/types.h> 40 #include <linux/types.h>
41 #include <linux/slab.h> 41 #include <linux/slab.h>
42 #include <linux/highmem.h> 42 #include <linux/highmem.h>
43 #include <linux/quotaops.h> 43 #include <linux/quotaops.h>
44 44
45 #include <cluster/masklog.h> 45 #include <cluster/masklog.h>
46 46
47 #include "ocfs2.h" 47 #include "ocfs2.h"
48 48
49 #include "alloc.h" 49 #include "alloc.h"
50 #include "dcache.h" 50 #include "dcache.h"
51 #include "dir.h" 51 #include "dir.h"
52 #include "dlmglue.h" 52 #include "dlmglue.h"
53 #include "extent_map.h" 53 #include "extent_map.h"
54 #include "file.h" 54 #include "file.h"
55 #include "inode.h" 55 #include "inode.h"
56 #include "journal.h" 56 #include "journal.h"
57 #include "namei.h" 57 #include "namei.h"
58 #include "suballoc.h" 58 #include "suballoc.h"
59 #include "super.h" 59 #include "super.h"
60 #include "symlink.h" 60 #include "symlink.h"
61 #include "sysfile.h" 61 #include "sysfile.h"
62 #include "uptodate.h" 62 #include "uptodate.h"
63 #include "xattr.h" 63 #include "xattr.h"
64 #include "acl.h" 64 #include "acl.h"
65 #include "ocfs2_trace.h" 65 #include "ocfs2_trace.h"
66 66
67 #include "buffer_head_io.h" 67 #include "buffer_head_io.h"
68 68
69 static int ocfs2_mknod_locked(struct ocfs2_super *osb, 69 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
70 struct inode *dir, 70 struct inode *dir,
71 struct inode *inode, 71 struct inode *inode,
72 dev_t dev, 72 dev_t dev,
73 struct buffer_head **new_fe_bh, 73 struct buffer_head **new_fe_bh,
74 struct buffer_head *parent_fe_bh, 74 struct buffer_head *parent_fe_bh,
75 handle_t *handle, 75 handle_t *handle,
76 struct ocfs2_alloc_context *inode_ac); 76 struct ocfs2_alloc_context *inode_ac);
77 77
78 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb, 78 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
79 struct inode **ret_orphan_dir, 79 struct inode **ret_orphan_dir,
80 u64 blkno, 80 u64 blkno,
81 char *name, 81 char *name,
82 struct ocfs2_dir_lookup_result *lookup); 82 struct ocfs2_dir_lookup_result *lookup);
83 83
84 static int ocfs2_orphan_add(struct ocfs2_super *osb, 84 static int ocfs2_orphan_add(struct ocfs2_super *osb,
85 handle_t *handle, 85 handle_t *handle,
86 struct inode *inode, 86 struct inode *inode,
87 struct buffer_head *fe_bh, 87 struct buffer_head *fe_bh,
88 char *name, 88 char *name,
89 struct ocfs2_dir_lookup_result *lookup, 89 struct ocfs2_dir_lookup_result *lookup,
90 struct inode *orphan_dir_inode); 90 struct inode *orphan_dir_inode);
91 91
92 static int ocfs2_create_symlink_data(struct ocfs2_super *osb, 92 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
93 handle_t *handle, 93 handle_t *handle,
94 struct inode *inode, 94 struct inode *inode,
95 const char *symname); 95 const char *symname);
96 96
97 static int ocfs2_double_lock(struct ocfs2_super *osb,
98 struct buffer_head **bh1,
99 struct inode *inode1,
100 struct buffer_head **bh2,
101 struct inode *inode2,
102 int rename);
103
104 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2);
97 /* An orphan dir name is an 8 byte value, printed as a hex string */ 105 /* An orphan dir name is an 8 byte value, printed as a hex string */
98 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64))) 106 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
99 107
100 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry, 108 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
101 unsigned int flags) 109 unsigned int flags)
102 { 110 {
103 int status; 111 int status;
104 u64 blkno; 112 u64 blkno;
105 struct inode *inode = NULL; 113 struct inode *inode = NULL;
106 struct dentry *ret; 114 struct dentry *ret;
107 struct ocfs2_inode_info *oi; 115 struct ocfs2_inode_info *oi;
108 116
109 trace_ocfs2_lookup(dir, dentry, dentry->d_name.len, 117 trace_ocfs2_lookup(dir, dentry, dentry->d_name.len,
110 dentry->d_name.name, 118 dentry->d_name.name,
111 (unsigned long long)OCFS2_I(dir)->ip_blkno, 0); 119 (unsigned long long)OCFS2_I(dir)->ip_blkno, 0);
112 120
113 if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) { 121 if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
114 ret = ERR_PTR(-ENAMETOOLONG); 122 ret = ERR_PTR(-ENAMETOOLONG);
115 goto bail; 123 goto bail;
116 } 124 }
117 125
118 status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT); 126 status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT);
119 if (status < 0) { 127 if (status < 0) {
120 if (status != -ENOENT) 128 if (status != -ENOENT)
121 mlog_errno(status); 129 mlog_errno(status);
122 ret = ERR_PTR(status); 130 ret = ERR_PTR(status);
123 goto bail; 131 goto bail;
124 } 132 }
125 133
126 status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name, 134 status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
127 dentry->d_name.len, &blkno); 135 dentry->d_name.len, &blkno);
128 if (status < 0) 136 if (status < 0)
129 goto bail_add; 137 goto bail_add;
130 138
131 inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0); 139 inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
132 if (IS_ERR(inode)) { 140 if (IS_ERR(inode)) {
133 ret = ERR_PTR(-EACCES); 141 ret = ERR_PTR(-EACCES);
134 goto bail_unlock; 142 goto bail_unlock;
135 } 143 }
136 144
137 oi = OCFS2_I(inode); 145 oi = OCFS2_I(inode);
138 /* Clear any orphaned state... If we were able to look up the 146 /* Clear any orphaned state... If we were able to look up the
139 * inode from a directory, it certainly can't be orphaned. We 147 * inode from a directory, it certainly can't be orphaned. We
140 * might have the bad state from a node which intended to 148 * might have the bad state from a node which intended to
141 * orphan this inode but crashed before it could commit the 149 * orphan this inode but crashed before it could commit the
142 * unlink. */ 150 * unlink. */
143 spin_lock(&oi->ip_lock); 151 spin_lock(&oi->ip_lock);
144 oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED; 152 oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
145 spin_unlock(&oi->ip_lock); 153 spin_unlock(&oi->ip_lock);
146 154
147 bail_add: 155 bail_add:
148 ret = d_splice_alias(inode, dentry); 156 ret = d_splice_alias(inode, dentry);
149 157
150 if (inode) { 158 if (inode) {
151 /* 159 /*
152 * If d_splice_alias() finds a DCACHE_DISCONNECTED 160 * If d_splice_alias() finds a DCACHE_DISCONNECTED
153 * dentry, it will d_move() it on top of ourse. The 161 * dentry, it will d_move() it on top of ourse. The
154 * return value will indicate this however, so in 162 * return value will indicate this however, so in
155 * those cases, we switch them around for the locking 163 * those cases, we switch them around for the locking
156 * code. 164 * code.
157 * 165 *
158 * NOTE: This dentry already has ->d_op set from 166 * NOTE: This dentry already has ->d_op set from
159 * ocfs2_get_parent() and ocfs2_get_dentry() 167 * ocfs2_get_parent() and ocfs2_get_dentry()
160 */ 168 */
161 if (!IS_ERR_OR_NULL(ret)) 169 if (!IS_ERR_OR_NULL(ret))
162 dentry = ret; 170 dentry = ret;
163 171
164 status = ocfs2_dentry_attach_lock(dentry, inode, 172 status = ocfs2_dentry_attach_lock(dentry, inode,
165 OCFS2_I(dir)->ip_blkno); 173 OCFS2_I(dir)->ip_blkno);
166 if (status) { 174 if (status) {
167 mlog_errno(status); 175 mlog_errno(status);
168 ret = ERR_PTR(status); 176 ret = ERR_PTR(status);
169 goto bail_unlock; 177 goto bail_unlock;
170 } 178 }
171 } else 179 } else
172 ocfs2_dentry_attach_gen(dentry); 180 ocfs2_dentry_attach_gen(dentry);
173 181
174 bail_unlock: 182 bail_unlock:
175 /* Don't drop the cluster lock until *after* the d_add -- 183 /* Don't drop the cluster lock until *after* the d_add --
176 * unlink on another node will message us to remove that 184 * unlink on another node will message us to remove that
177 * dentry under this lock so otherwise we can race this with 185 * dentry under this lock so otherwise we can race this with
178 * the downconvert thread and have a stale dentry. */ 186 * the downconvert thread and have a stale dentry. */
179 ocfs2_inode_unlock(dir, 0); 187 ocfs2_inode_unlock(dir, 0);
180 188
181 bail: 189 bail:
182 190
183 trace_ocfs2_lookup_ret(ret); 191 trace_ocfs2_lookup_ret(ret);
184 192
185 return ret; 193 return ret;
186 } 194 }
187 195
188 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode) 196 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode)
189 { 197 {
190 struct inode *inode; 198 struct inode *inode;
191 199
192 inode = new_inode(dir->i_sb); 200 inode = new_inode(dir->i_sb);
193 if (!inode) { 201 if (!inode) {
194 mlog(ML_ERROR, "new_inode failed!\n"); 202 mlog(ML_ERROR, "new_inode failed!\n");
195 return NULL; 203 return NULL;
196 } 204 }
197 205
198 /* populate as many fields early on as possible - many of 206 /* populate as many fields early on as possible - many of
199 * these are used by the support functions here and in 207 * these are used by the support functions here and in
200 * callers. */ 208 * callers. */
201 if (S_ISDIR(mode)) 209 if (S_ISDIR(mode))
202 set_nlink(inode, 2); 210 set_nlink(inode, 2);
203 inode_init_owner(inode, dir, mode); 211 inode_init_owner(inode, dir, mode);
204 dquot_initialize(inode); 212 dquot_initialize(inode);
205 return inode; 213 return inode;
206 } 214 }
207 215
208 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super *osb, 216 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super *osb,
209 struct dentry *dentry, struct inode *inode) 217 struct dentry *dentry, struct inode *inode)
210 { 218 {
211 struct ocfs2_dentry_lock *dl = dentry->d_fsdata; 219 struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
212 220
213 ocfs2_simple_drop_lockres(osb, &dl->dl_lockres); 221 ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
214 ocfs2_lock_res_free(&dl->dl_lockres); 222 ocfs2_lock_res_free(&dl->dl_lockres);
215 BUG_ON(dl->dl_count != 1); 223 BUG_ON(dl->dl_count != 1);
216 spin_lock(&dentry_attach_lock); 224 spin_lock(&dentry_attach_lock);
217 dentry->d_fsdata = NULL; 225 dentry->d_fsdata = NULL;
218 spin_unlock(&dentry_attach_lock); 226 spin_unlock(&dentry_attach_lock);
219 kfree(dl); 227 kfree(dl);
220 iput(inode); 228 iput(inode);
221 } 229 }
222 230
223 static int ocfs2_mknod(struct inode *dir, 231 static int ocfs2_mknod(struct inode *dir,
224 struct dentry *dentry, 232 struct dentry *dentry,
225 umode_t mode, 233 umode_t mode,
226 dev_t dev) 234 dev_t dev)
227 { 235 {
228 int status = 0; 236 int status = 0;
229 struct buffer_head *parent_fe_bh = NULL; 237 struct buffer_head *parent_fe_bh = NULL;
230 handle_t *handle = NULL; 238 handle_t *handle = NULL;
231 struct ocfs2_super *osb; 239 struct ocfs2_super *osb;
232 struct ocfs2_dinode *dirfe; 240 struct ocfs2_dinode *dirfe;
233 struct buffer_head *new_fe_bh = NULL; 241 struct buffer_head *new_fe_bh = NULL;
234 struct inode *inode = NULL; 242 struct inode *inode = NULL;
235 struct ocfs2_alloc_context *inode_ac = NULL; 243 struct ocfs2_alloc_context *inode_ac = NULL;
236 struct ocfs2_alloc_context *data_ac = NULL; 244 struct ocfs2_alloc_context *data_ac = NULL;
237 struct ocfs2_alloc_context *meta_ac = NULL; 245 struct ocfs2_alloc_context *meta_ac = NULL;
238 int want_clusters = 0; 246 int want_clusters = 0;
239 int want_meta = 0; 247 int want_meta = 0;
240 int xattr_credits = 0; 248 int xattr_credits = 0;
241 struct ocfs2_security_xattr_info si = { 249 struct ocfs2_security_xattr_info si = {
242 .enable = 1, 250 .enable = 1,
243 }; 251 };
244 int did_quota_inode = 0; 252 int did_quota_inode = 0;
245 struct ocfs2_dir_lookup_result lookup = { NULL, }; 253 struct ocfs2_dir_lookup_result lookup = { NULL, };
246 sigset_t oldset; 254 sigset_t oldset;
247 int did_block_signals = 0; 255 int did_block_signals = 0;
248 struct posix_acl *default_acl = NULL, *acl = NULL; 256 struct posix_acl *default_acl = NULL, *acl = NULL;
249 struct ocfs2_dentry_lock *dl = NULL; 257 struct ocfs2_dentry_lock *dl = NULL;
250 258
251 trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name, 259 trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name,
252 (unsigned long long)OCFS2_I(dir)->ip_blkno, 260 (unsigned long long)OCFS2_I(dir)->ip_blkno,
253 (unsigned long)dev, mode); 261 (unsigned long)dev, mode);
254 262
255 dquot_initialize(dir); 263 dquot_initialize(dir);
256 264
257 /* get our super block */ 265 /* get our super block */
258 osb = OCFS2_SB(dir->i_sb); 266 osb = OCFS2_SB(dir->i_sb);
259 267
260 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1); 268 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
261 if (status < 0) { 269 if (status < 0) {
262 if (status != -ENOENT) 270 if (status != -ENOENT)
263 mlog_errno(status); 271 mlog_errno(status);
264 return status; 272 return status;
265 } 273 }
266 274
267 if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) { 275 if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) {
268 status = -EMLINK; 276 status = -EMLINK;
269 goto leave; 277 goto leave;
270 } 278 }
271 279
272 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data; 280 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
273 if (!ocfs2_read_links_count(dirfe)) { 281 if (!ocfs2_read_links_count(dirfe)) {
274 /* can't make a file in a deleted directory. */ 282 /* can't make a file in a deleted directory. */
275 status = -ENOENT; 283 status = -ENOENT;
276 goto leave; 284 goto leave;
277 } 285 }
278 286
279 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 287 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
280 dentry->d_name.len); 288 dentry->d_name.len);
281 if (status) 289 if (status)
282 goto leave; 290 goto leave;
283 291
284 /* get a spot inside the dir. */ 292 /* get a spot inside the dir. */
285 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh, 293 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
286 dentry->d_name.name, 294 dentry->d_name.name,
287 dentry->d_name.len, &lookup); 295 dentry->d_name.len, &lookup);
288 if (status < 0) { 296 if (status < 0) {
289 mlog_errno(status); 297 mlog_errno(status);
290 goto leave; 298 goto leave;
291 } 299 }
292 300
293 /* reserve an inode spot */ 301 /* reserve an inode spot */
294 status = ocfs2_reserve_new_inode(osb, &inode_ac); 302 status = ocfs2_reserve_new_inode(osb, &inode_ac);
295 if (status < 0) { 303 if (status < 0) {
296 if (status != -ENOSPC) 304 if (status != -ENOSPC)
297 mlog_errno(status); 305 mlog_errno(status);
298 goto leave; 306 goto leave;
299 } 307 }
300 308
301 inode = ocfs2_get_init_inode(dir, mode); 309 inode = ocfs2_get_init_inode(dir, mode);
302 if (!inode) { 310 if (!inode) {
303 status = -ENOMEM; 311 status = -ENOMEM;
304 mlog_errno(status); 312 mlog_errno(status);
305 goto leave; 313 goto leave;
306 } 314 }
307 315
308 /* get security xattr */ 316 /* get security xattr */
309 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si); 317 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
310 if (status) { 318 if (status) {
311 if (status == -EOPNOTSUPP) 319 if (status == -EOPNOTSUPP)
312 si.enable = 0; 320 si.enable = 0;
313 else { 321 else {
314 mlog_errno(status); 322 mlog_errno(status);
315 goto leave; 323 goto leave;
316 } 324 }
317 } 325 }
318 326
319 /* calculate meta data/clusters for setting security and acl xattr */ 327 /* calculate meta data/clusters for setting security and acl xattr */
320 status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode, 328 status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode,
321 &si, &want_clusters, 329 &si, &want_clusters,
322 &xattr_credits, &want_meta); 330 &xattr_credits, &want_meta);
323 if (status < 0) { 331 if (status < 0) {
324 mlog_errno(status); 332 mlog_errno(status);
325 goto leave; 333 goto leave;
326 } 334 }
327 335
328 /* Reserve a cluster if creating an extent based directory. */ 336 /* Reserve a cluster if creating an extent based directory. */
329 if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) { 337 if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
330 want_clusters += 1; 338 want_clusters += 1;
331 339
332 /* Dir indexing requires extra space as well */ 340 /* Dir indexing requires extra space as well */
333 if (ocfs2_supports_indexed_dirs(osb)) 341 if (ocfs2_supports_indexed_dirs(osb))
334 want_meta++; 342 want_meta++;
335 } 343 }
336 344
337 status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac); 345 status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
338 if (status < 0) { 346 if (status < 0) {
339 if (status != -ENOSPC) 347 if (status != -ENOSPC)
340 mlog_errno(status); 348 mlog_errno(status);
341 goto leave; 349 goto leave;
342 } 350 }
343 351
344 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac); 352 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
345 if (status < 0) { 353 if (status < 0) {
346 if (status != -ENOSPC) 354 if (status != -ENOSPC)
347 mlog_errno(status); 355 mlog_errno(status);
348 goto leave; 356 goto leave;
349 } 357 }
350 358
351 status = posix_acl_create(dir, &mode, &default_acl, &acl); 359 status = posix_acl_create(dir, &mode, &default_acl, &acl);
352 if (status) { 360 if (status) {
353 mlog_errno(status); 361 mlog_errno(status);
354 goto leave; 362 goto leave;
355 } 363 }
356 364
357 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 365 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb,
358 S_ISDIR(mode), 366 S_ISDIR(mode),
359 xattr_credits)); 367 xattr_credits));
360 if (IS_ERR(handle)) { 368 if (IS_ERR(handle)) {
361 status = PTR_ERR(handle); 369 status = PTR_ERR(handle);
362 handle = NULL; 370 handle = NULL;
363 mlog_errno(status); 371 mlog_errno(status);
364 goto leave; 372 goto leave;
365 } 373 }
366 374
367 /* Starting to change things, restart is no longer possible. */ 375 /* Starting to change things, restart is no longer possible. */
368 ocfs2_block_signals(&oldset); 376 ocfs2_block_signals(&oldset);
369 did_block_signals = 1; 377 did_block_signals = 1;
370 378
371 status = dquot_alloc_inode(inode); 379 status = dquot_alloc_inode(inode);
372 if (status) 380 if (status)
373 goto leave; 381 goto leave;
374 did_quota_inode = 1; 382 did_quota_inode = 1;
375 383
376 /* do the real work now. */ 384 /* do the real work now. */
377 status = ocfs2_mknod_locked(osb, dir, inode, dev, 385 status = ocfs2_mknod_locked(osb, dir, inode, dev,
378 &new_fe_bh, parent_fe_bh, handle, 386 &new_fe_bh, parent_fe_bh, handle,
379 inode_ac); 387 inode_ac);
380 if (status < 0) { 388 if (status < 0) {
381 mlog_errno(status); 389 mlog_errno(status);
382 goto leave; 390 goto leave;
383 } 391 }
384 392
385 if (S_ISDIR(mode)) { 393 if (S_ISDIR(mode)) {
386 status = ocfs2_fill_new_dir(osb, handle, dir, inode, 394 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
387 new_fe_bh, data_ac, meta_ac); 395 new_fe_bh, data_ac, meta_ac);
388 if (status < 0) { 396 if (status < 0) {
389 mlog_errno(status); 397 mlog_errno(status);
390 goto leave; 398 goto leave;
391 } 399 }
392 400
393 status = ocfs2_journal_access_di(handle, INODE_CACHE(dir), 401 status = ocfs2_journal_access_di(handle, INODE_CACHE(dir),
394 parent_fe_bh, 402 parent_fe_bh,
395 OCFS2_JOURNAL_ACCESS_WRITE); 403 OCFS2_JOURNAL_ACCESS_WRITE);
396 if (status < 0) { 404 if (status < 0) {
397 mlog_errno(status); 405 mlog_errno(status);
398 goto leave; 406 goto leave;
399 } 407 }
400 ocfs2_add_links_count(dirfe, 1); 408 ocfs2_add_links_count(dirfe, 1);
401 ocfs2_journal_dirty(handle, parent_fe_bh); 409 ocfs2_journal_dirty(handle, parent_fe_bh);
402 inc_nlink(dir); 410 inc_nlink(dir);
403 } 411 }
404 412
405 if (default_acl) { 413 if (default_acl) {
406 status = ocfs2_set_acl(handle, inode, new_fe_bh, 414 status = ocfs2_set_acl(handle, inode, new_fe_bh,
407 ACL_TYPE_DEFAULT, default_acl, 415 ACL_TYPE_DEFAULT, default_acl,
408 meta_ac, data_ac); 416 meta_ac, data_ac);
409 } 417 }
410 if (!status && acl) { 418 if (!status && acl) {
411 status = ocfs2_set_acl(handle, inode, new_fe_bh, 419 status = ocfs2_set_acl(handle, inode, new_fe_bh,
412 ACL_TYPE_ACCESS, acl, 420 ACL_TYPE_ACCESS, acl,
413 meta_ac, data_ac); 421 meta_ac, data_ac);
414 } 422 }
415 423
416 if (status < 0) { 424 if (status < 0) {
417 mlog_errno(status); 425 mlog_errno(status);
418 goto leave; 426 goto leave;
419 } 427 }
420 428
421 if (si.enable) { 429 if (si.enable) {
422 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si, 430 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
423 meta_ac, data_ac); 431 meta_ac, data_ac);
424 if (status < 0) { 432 if (status < 0) {
425 mlog_errno(status); 433 mlog_errno(status);
426 goto leave; 434 goto leave;
427 } 435 }
428 } 436 }
429 437
430 /* 438 /*
431 * Do this before adding the entry to the directory. We add 439 * Do this before adding the entry to the directory. We add
432 * also set d_op after success so that ->d_iput() will cleanup 440 * also set d_op after success so that ->d_iput() will cleanup
433 * the dentry lock even if ocfs2_add_entry() fails below. 441 * the dentry lock even if ocfs2_add_entry() fails below.
434 */ 442 */
435 status = ocfs2_dentry_attach_lock(dentry, inode, 443 status = ocfs2_dentry_attach_lock(dentry, inode,
436 OCFS2_I(dir)->ip_blkno); 444 OCFS2_I(dir)->ip_blkno);
437 if (status) { 445 if (status) {
438 mlog_errno(status); 446 mlog_errno(status);
439 goto leave; 447 goto leave;
440 } 448 }
441 449
442 dl = dentry->d_fsdata; 450 dl = dentry->d_fsdata;
443 451
444 status = ocfs2_add_entry(handle, dentry, inode, 452 status = ocfs2_add_entry(handle, dentry, inode,
445 OCFS2_I(inode)->ip_blkno, parent_fe_bh, 453 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
446 &lookup); 454 &lookup);
447 if (status < 0) { 455 if (status < 0) {
448 mlog_errno(status); 456 mlog_errno(status);
449 goto leave; 457 goto leave;
450 } 458 }
451 459
452 insert_inode_hash(inode); 460 insert_inode_hash(inode);
453 d_instantiate(dentry, inode); 461 d_instantiate(dentry, inode);
454 status = 0; 462 status = 0;
455 leave: 463 leave:
456 if (default_acl) 464 if (default_acl)
457 posix_acl_release(default_acl); 465 posix_acl_release(default_acl);
458 if (acl) 466 if (acl)
459 posix_acl_release(acl); 467 posix_acl_release(acl);
460 if (status < 0 && did_quota_inode) 468 if (status < 0 && did_quota_inode)
461 dquot_free_inode(inode); 469 dquot_free_inode(inode);
462 if (handle) 470 if (handle)
463 ocfs2_commit_trans(osb, handle); 471 ocfs2_commit_trans(osb, handle);
464 472
465 ocfs2_inode_unlock(dir, 1); 473 ocfs2_inode_unlock(dir, 1);
466 if (did_block_signals) 474 if (did_block_signals)
467 ocfs2_unblock_signals(&oldset); 475 ocfs2_unblock_signals(&oldset);
468 476
469 brelse(new_fe_bh); 477 brelse(new_fe_bh);
470 brelse(parent_fe_bh); 478 brelse(parent_fe_bh);
471 kfree(si.value); 479 kfree(si.value);
472 480
473 ocfs2_free_dir_lookup_result(&lookup); 481 ocfs2_free_dir_lookup_result(&lookup);
474 482
475 if (inode_ac) 483 if (inode_ac)
476 ocfs2_free_alloc_context(inode_ac); 484 ocfs2_free_alloc_context(inode_ac);
477 485
478 if (data_ac) 486 if (data_ac)
479 ocfs2_free_alloc_context(data_ac); 487 ocfs2_free_alloc_context(data_ac);
480 488
481 if (meta_ac) 489 if (meta_ac)
482 ocfs2_free_alloc_context(meta_ac); 490 ocfs2_free_alloc_context(meta_ac);
483 491
484 /* 492 /*
485 * We should call iput after the i_mutex of the bitmap been 493 * We should call iput after the i_mutex of the bitmap been
486 * unlocked in ocfs2_free_alloc_context, or the 494 * unlocked in ocfs2_free_alloc_context, or the
487 * ocfs2_delete_inode will mutex_lock again. 495 * ocfs2_delete_inode will mutex_lock again.
488 */ 496 */
489 if ((status < 0) && inode) { 497 if ((status < 0) && inode) {
490 if (dl) 498 if (dl)
491 ocfs2_cleanup_add_entry_failure(osb, dentry, inode); 499 ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
492 500
493 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR; 501 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
494 clear_nlink(inode); 502 clear_nlink(inode);
495 iput(inode); 503 iput(inode);
496 } 504 }
497 505
498 if (status) 506 if (status)
499 mlog_errno(status); 507 mlog_errno(status);
500 508
501 return status; 509 return status;
502 } 510 }
503 511
504 static int __ocfs2_mknod_locked(struct inode *dir, 512 static int __ocfs2_mknod_locked(struct inode *dir,
505 struct inode *inode, 513 struct inode *inode,
506 dev_t dev, 514 dev_t dev,
507 struct buffer_head **new_fe_bh, 515 struct buffer_head **new_fe_bh,
508 struct buffer_head *parent_fe_bh, 516 struct buffer_head *parent_fe_bh,
509 handle_t *handle, 517 handle_t *handle,
510 struct ocfs2_alloc_context *inode_ac, 518 struct ocfs2_alloc_context *inode_ac,
511 u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit) 519 u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit)
512 { 520 {
513 int status = 0; 521 int status = 0;
514 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 522 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
515 struct ocfs2_dinode *fe = NULL; 523 struct ocfs2_dinode *fe = NULL;
516 struct ocfs2_extent_list *fel; 524 struct ocfs2_extent_list *fel;
517 u16 feat; 525 u16 feat;
518 struct ocfs2_inode_info *oi = OCFS2_I(inode); 526 struct ocfs2_inode_info *oi = OCFS2_I(inode);
519 527
520 *new_fe_bh = NULL; 528 *new_fe_bh = NULL;
521 529
522 /* populate as many fields early on as possible - many of 530 /* populate as many fields early on as possible - many of
523 * these are used by the support functions here and in 531 * these are used by the support functions here and in
524 * callers. */ 532 * callers. */
525 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno); 533 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
526 OCFS2_I(inode)->ip_blkno = fe_blkno; 534 OCFS2_I(inode)->ip_blkno = fe_blkno;
527 spin_lock(&osb->osb_lock); 535 spin_lock(&osb->osb_lock);
528 inode->i_generation = osb->s_next_generation++; 536 inode->i_generation = osb->s_next_generation++;
529 spin_unlock(&osb->osb_lock); 537 spin_unlock(&osb->osb_lock);
530 538
531 *new_fe_bh = sb_getblk(osb->sb, fe_blkno); 539 *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
532 if (!*new_fe_bh) { 540 if (!*new_fe_bh) {
533 status = -ENOMEM; 541 status = -ENOMEM;
534 mlog_errno(status); 542 mlog_errno(status);
535 goto leave; 543 goto leave;
536 } 544 }
537 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh); 545 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh);
538 546
539 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), 547 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
540 *new_fe_bh, 548 *new_fe_bh,
541 OCFS2_JOURNAL_ACCESS_CREATE); 549 OCFS2_JOURNAL_ACCESS_CREATE);
542 if (status < 0) { 550 if (status < 0) {
543 mlog_errno(status); 551 mlog_errno(status);
544 goto leave; 552 goto leave;
545 } 553 }
546 554
547 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data; 555 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
548 memset(fe, 0, osb->sb->s_blocksize); 556 memset(fe, 0, osb->sb->s_blocksize);
549 557
550 fe->i_generation = cpu_to_le32(inode->i_generation); 558 fe->i_generation = cpu_to_le32(inode->i_generation);
551 fe->i_fs_generation = cpu_to_le32(osb->fs_generation); 559 fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
552 fe->i_blkno = cpu_to_le64(fe_blkno); 560 fe->i_blkno = cpu_to_le64(fe_blkno);
553 fe->i_suballoc_loc = cpu_to_le64(suballoc_loc); 561 fe->i_suballoc_loc = cpu_to_le64(suballoc_loc);
554 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit); 562 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
555 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot); 563 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
556 fe->i_uid = cpu_to_le32(i_uid_read(inode)); 564 fe->i_uid = cpu_to_le32(i_uid_read(inode));
557 fe->i_gid = cpu_to_le32(i_gid_read(inode)); 565 fe->i_gid = cpu_to_le32(i_gid_read(inode));
558 fe->i_mode = cpu_to_le16(inode->i_mode); 566 fe->i_mode = cpu_to_le16(inode->i_mode);
559 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 567 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
560 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev)); 568 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
561 569
562 ocfs2_set_links_count(fe, inode->i_nlink); 570 ocfs2_set_links_count(fe, inode->i_nlink);
563 571
564 fe->i_last_eb_blk = 0; 572 fe->i_last_eb_blk = 0;
565 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE); 573 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
566 fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL); 574 fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
567 fe->i_atime = fe->i_ctime = fe->i_mtime = 575 fe->i_atime = fe->i_ctime = fe->i_mtime =
568 cpu_to_le64(CURRENT_TIME.tv_sec); 576 cpu_to_le64(CURRENT_TIME.tv_sec);
569 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec = 577 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
570 cpu_to_le32(CURRENT_TIME.tv_nsec); 578 cpu_to_le32(CURRENT_TIME.tv_nsec);
571 fe->i_dtime = 0; 579 fe->i_dtime = 0;
572 580
573 /* 581 /*
574 * If supported, directories start with inline data. If inline 582 * If supported, directories start with inline data. If inline
575 * isn't supported, but indexing is, we start them as indexed. 583 * isn't supported, but indexing is, we start them as indexed.
576 */ 584 */
577 feat = le16_to_cpu(fe->i_dyn_features); 585 feat = le16_to_cpu(fe->i_dyn_features);
578 if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) { 586 if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
579 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL); 587 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
580 588
581 fe->id2.i_data.id_count = cpu_to_le16( 589 fe->id2.i_data.id_count = cpu_to_le16(
582 ocfs2_max_inline_data_with_xattr(osb->sb, fe)); 590 ocfs2_max_inline_data_with_xattr(osb->sb, fe));
583 } else { 591 } else {
584 fel = &fe->id2.i_list; 592 fel = &fe->id2.i_list;
585 fel->l_tree_depth = 0; 593 fel->l_tree_depth = 0;
586 fel->l_next_free_rec = 0; 594 fel->l_next_free_rec = 0;
587 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb)); 595 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
588 } 596 }
589 597
590 ocfs2_journal_dirty(handle, *new_fe_bh); 598 ocfs2_journal_dirty(handle, *new_fe_bh);
591 599
592 ocfs2_populate_inode(inode, fe, 1); 600 ocfs2_populate_inode(inode, fe, 1);
593 ocfs2_ci_set_new(osb, INODE_CACHE(inode)); 601 ocfs2_ci_set_new(osb, INODE_CACHE(inode));
594 if (!ocfs2_mount_local(osb)) { 602 if (!ocfs2_mount_local(osb)) {
595 status = ocfs2_create_new_inode_locks(inode); 603 status = ocfs2_create_new_inode_locks(inode);
596 if (status < 0) 604 if (status < 0)
597 mlog_errno(status); 605 mlog_errno(status);
598 } 606 }
599 607
600 oi->i_sync_tid = handle->h_transaction->t_tid; 608 oi->i_sync_tid = handle->h_transaction->t_tid;
601 oi->i_datasync_tid = handle->h_transaction->t_tid; 609 oi->i_datasync_tid = handle->h_transaction->t_tid;
602 610
603 leave: 611 leave:
604 if (status < 0) { 612 if (status < 0) {
605 if (*new_fe_bh) { 613 if (*new_fe_bh) {
606 brelse(*new_fe_bh); 614 brelse(*new_fe_bh);
607 *new_fe_bh = NULL; 615 *new_fe_bh = NULL;
608 } 616 }
609 } 617 }
610 618
611 if (status) 619 if (status)
612 mlog_errno(status); 620 mlog_errno(status);
613 return status; 621 return status;
614 } 622 }
615 623
616 static int ocfs2_mknod_locked(struct ocfs2_super *osb, 624 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
617 struct inode *dir, 625 struct inode *dir,
618 struct inode *inode, 626 struct inode *inode,
619 dev_t dev, 627 dev_t dev,
620 struct buffer_head **new_fe_bh, 628 struct buffer_head **new_fe_bh,
621 struct buffer_head *parent_fe_bh, 629 struct buffer_head *parent_fe_bh,
622 handle_t *handle, 630 handle_t *handle,
623 struct ocfs2_alloc_context *inode_ac) 631 struct ocfs2_alloc_context *inode_ac)
624 { 632 {
625 int status = 0; 633 int status = 0;
626 u64 suballoc_loc, fe_blkno = 0; 634 u64 suballoc_loc, fe_blkno = 0;
627 u16 suballoc_bit; 635 u16 suballoc_bit;
628 636
629 *new_fe_bh = NULL; 637 *new_fe_bh = NULL;
630 638
631 status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh, 639 status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh,
632 inode_ac, &suballoc_loc, 640 inode_ac, &suballoc_loc,
633 &suballoc_bit, &fe_blkno); 641 &suballoc_bit, &fe_blkno);
634 if (status < 0) { 642 if (status < 0) {
635 mlog_errno(status); 643 mlog_errno(status);
636 return status; 644 return status;
637 } 645 }
638 646
639 return __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh, 647 return __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh,
640 parent_fe_bh, handle, inode_ac, 648 parent_fe_bh, handle, inode_ac,
641 fe_blkno, suballoc_loc, suballoc_bit); 649 fe_blkno, suballoc_loc, suballoc_bit);
642 } 650 }
643 651
644 static int ocfs2_mkdir(struct inode *dir, 652 static int ocfs2_mkdir(struct inode *dir,
645 struct dentry *dentry, 653 struct dentry *dentry,
646 umode_t mode) 654 umode_t mode)
647 { 655 {
648 int ret; 656 int ret;
649 657
650 trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name, 658 trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name,
651 OCFS2_I(dir)->ip_blkno, mode); 659 OCFS2_I(dir)->ip_blkno, mode);
652 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0); 660 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
653 if (ret) 661 if (ret)
654 mlog_errno(ret); 662 mlog_errno(ret);
655 663
656 return ret; 664 return ret;
657 } 665 }
658 666
659 static int ocfs2_create(struct inode *dir, 667 static int ocfs2_create(struct inode *dir,
660 struct dentry *dentry, 668 struct dentry *dentry,
661 umode_t mode, 669 umode_t mode,
662 bool excl) 670 bool excl)
663 { 671 {
664 int ret; 672 int ret;
665 673
666 trace_ocfs2_create(dir, dentry, dentry->d_name.len, dentry->d_name.name, 674 trace_ocfs2_create(dir, dentry, dentry->d_name.len, dentry->d_name.name,
667 (unsigned long long)OCFS2_I(dir)->ip_blkno, mode); 675 (unsigned long long)OCFS2_I(dir)->ip_blkno, mode);
668 ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0); 676 ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
669 if (ret) 677 if (ret)
670 mlog_errno(ret); 678 mlog_errno(ret);
671 679
672 return ret; 680 return ret;
673 } 681 }
674 682
675 static int ocfs2_link(struct dentry *old_dentry, 683 static int ocfs2_link(struct dentry *old_dentry,
676 struct inode *dir, 684 struct inode *dir,
677 struct dentry *dentry) 685 struct dentry *dentry)
678 { 686 {
679 handle_t *handle; 687 handle_t *handle;
680 struct inode *inode = old_dentry->d_inode; 688 struct inode *inode = old_dentry->d_inode;
689 struct inode *old_dir = old_dentry->d_parent->d_inode;
681 int err; 690 int err;
682 struct buffer_head *fe_bh = NULL; 691 struct buffer_head *fe_bh = NULL;
692 struct buffer_head *old_dir_bh = NULL;
683 struct buffer_head *parent_fe_bh = NULL; 693 struct buffer_head *parent_fe_bh = NULL;
684 struct ocfs2_dinode *fe = NULL; 694 struct ocfs2_dinode *fe = NULL;
685 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 695 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
686 struct ocfs2_dir_lookup_result lookup = { NULL, }; 696 struct ocfs2_dir_lookup_result lookup = { NULL, };
687 sigset_t oldset; 697 sigset_t oldset;
688 u64 old_de_ino; 698 u64 old_de_ino;
689 699
690 trace_ocfs2_link((unsigned long long)OCFS2_I(inode)->ip_blkno, 700 trace_ocfs2_link((unsigned long long)OCFS2_I(inode)->ip_blkno,
691 old_dentry->d_name.len, old_dentry->d_name.name, 701 old_dentry->d_name.len, old_dentry->d_name.name,
692 dentry->d_name.len, dentry->d_name.name); 702 dentry->d_name.len, dentry->d_name.name);
693 703
694 if (S_ISDIR(inode->i_mode)) 704 if (S_ISDIR(inode->i_mode))
695 return -EPERM; 705 return -EPERM;
696 706
697 dquot_initialize(dir); 707 dquot_initialize(dir);
698 708
699 err = ocfs2_inode_lock_nested(dir, &parent_fe_bh, 1, OI_LS_PARENT); 709 err = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
710 &parent_fe_bh, dir, 0);
700 if (err < 0) { 711 if (err < 0) {
701 if (err != -ENOENT) 712 if (err != -ENOENT)
702 mlog_errno(err); 713 mlog_errno(err);
703 return err; 714 return err;
704 } 715 }
705 716
717 /* make sure both dirs have bhs
718 * get an extra ref on old_dir_bh if old==new */
719 if (!parent_fe_bh) {
720 if (old_dir_bh) {
721 parent_fe_bh = old_dir_bh;
722 get_bh(parent_fe_bh);
723 } else {
724 mlog(ML_ERROR, "%s: no old_dir_bh!\n", osb->uuid_str);
725 err = -EIO;
726 goto out;
727 }
728 }
729
706 if (!dir->i_nlink) { 730 if (!dir->i_nlink) {
707 err = -ENOENT; 731 err = -ENOENT;
708 goto out; 732 goto out;
709 } 733 }
710 734
711 err = ocfs2_lookup_ino_from_name(dir, old_dentry->d_name.name, 735 err = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
712 old_dentry->d_name.len, &old_de_ino); 736 old_dentry->d_name.len, &old_de_ino);
713 if (err) { 737 if (err) {
714 err = -ENOENT; 738 err = -ENOENT;
715 goto out; 739 goto out;
716 } 740 }
717 741
718 /* 742 /*
719 * Check whether another node removed the source inode while we 743 * Check whether another node removed the source inode while we
720 * were in the vfs. 744 * were in the vfs.
721 */ 745 */
722 if (old_de_ino != OCFS2_I(inode)->ip_blkno) { 746 if (old_de_ino != OCFS2_I(inode)->ip_blkno) {
723 err = -ENOENT; 747 err = -ENOENT;
724 goto out; 748 goto out;
725 } 749 }
726 750
727 err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 751 err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
728 dentry->d_name.len); 752 dentry->d_name.len);
729 if (err) 753 if (err)
730 goto out; 754 goto out;
731 755
732 err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh, 756 err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
733 dentry->d_name.name, 757 dentry->d_name.name,
734 dentry->d_name.len, &lookup); 758 dentry->d_name.len, &lookup);
735 if (err < 0) { 759 if (err < 0) {
736 mlog_errno(err); 760 mlog_errno(err);
737 goto out; 761 goto out;
738 } 762 }
739 763
740 err = ocfs2_inode_lock(inode, &fe_bh, 1); 764 err = ocfs2_inode_lock(inode, &fe_bh, 1);
741 if (err < 0) { 765 if (err < 0) {
742 if (err != -ENOENT) 766 if (err != -ENOENT)
743 mlog_errno(err); 767 mlog_errno(err);
744 goto out; 768 goto out;
745 } 769 }
746 770
747 fe = (struct ocfs2_dinode *) fe_bh->b_data; 771 fe = (struct ocfs2_dinode *) fe_bh->b_data;
748 if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) { 772 if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) {
749 err = -EMLINK; 773 err = -EMLINK;
750 goto out_unlock_inode; 774 goto out_unlock_inode;
751 } 775 }
752 776
753 handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb)); 777 handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb));
754 if (IS_ERR(handle)) { 778 if (IS_ERR(handle)) {
755 err = PTR_ERR(handle); 779 err = PTR_ERR(handle);
756 handle = NULL; 780 handle = NULL;
757 mlog_errno(err); 781 mlog_errno(err);
758 goto out_unlock_inode; 782 goto out_unlock_inode;
759 } 783 }
760 784
761 /* Starting to change things, restart is no longer possible. */ 785 /* Starting to change things, restart is no longer possible. */
762 ocfs2_block_signals(&oldset); 786 ocfs2_block_signals(&oldset);
763 787
764 err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh, 788 err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
765 OCFS2_JOURNAL_ACCESS_WRITE); 789 OCFS2_JOURNAL_ACCESS_WRITE);
766 if (err < 0) { 790 if (err < 0) {
767 mlog_errno(err); 791 mlog_errno(err);
768 goto out_commit; 792 goto out_commit;
769 } 793 }
770 794
771 inc_nlink(inode); 795 inc_nlink(inode);
772 inode->i_ctime = CURRENT_TIME; 796 inode->i_ctime = CURRENT_TIME;
773 ocfs2_set_links_count(fe, inode->i_nlink); 797 ocfs2_set_links_count(fe, inode->i_nlink);
774 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 798 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
775 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 799 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
776 ocfs2_journal_dirty(handle, fe_bh); 800 ocfs2_journal_dirty(handle, fe_bh);
777 801
778 err = ocfs2_add_entry(handle, dentry, inode, 802 err = ocfs2_add_entry(handle, dentry, inode,
779 OCFS2_I(inode)->ip_blkno, 803 OCFS2_I(inode)->ip_blkno,
780 parent_fe_bh, &lookup); 804 parent_fe_bh, &lookup);
781 if (err) { 805 if (err) {
782 ocfs2_add_links_count(fe, -1); 806 ocfs2_add_links_count(fe, -1);
783 drop_nlink(inode); 807 drop_nlink(inode);
784 mlog_errno(err); 808 mlog_errno(err);
785 goto out_commit; 809 goto out_commit;
786 } 810 }
787 811
788 err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno); 812 err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
789 if (err) { 813 if (err) {
790 mlog_errno(err); 814 mlog_errno(err);
791 goto out_commit; 815 goto out_commit;
792 } 816 }
793 817
794 ihold(inode); 818 ihold(inode);
795 d_instantiate(dentry, inode); 819 d_instantiate(dentry, inode);
796 820
797 out_commit: 821 out_commit:
798 ocfs2_commit_trans(osb, handle); 822 ocfs2_commit_trans(osb, handle);
799 ocfs2_unblock_signals(&oldset); 823 ocfs2_unblock_signals(&oldset);
800 out_unlock_inode: 824 out_unlock_inode:
801 ocfs2_inode_unlock(inode, 1); 825 ocfs2_inode_unlock(inode, 1);
802 826
803 out: 827 out:
804 ocfs2_inode_unlock(dir, 1); 828 ocfs2_double_unlock(old_dir, dir);
805 829
806 brelse(fe_bh); 830 brelse(fe_bh);
807 brelse(parent_fe_bh); 831 brelse(parent_fe_bh);
832 brelse(old_dir_bh);
808 833
809 ocfs2_free_dir_lookup_result(&lookup); 834 ocfs2_free_dir_lookup_result(&lookup);
810 835
811 if (err) 836 if (err)
812 mlog_errno(err); 837 mlog_errno(err);
813 838
814 return err; 839 return err;
815 } 840 }
816 841
817 /* 842 /*
818 * Takes and drops an exclusive lock on the given dentry. This will 843 * Takes and drops an exclusive lock on the given dentry. This will
819 * force other nodes to drop it. 844 * force other nodes to drop it.
820 */ 845 */
821 static int ocfs2_remote_dentry_delete(struct dentry *dentry) 846 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
822 { 847 {
823 int ret; 848 int ret;
824 849
825 ret = ocfs2_dentry_lock(dentry, 1); 850 ret = ocfs2_dentry_lock(dentry, 1);
826 if (ret) 851 if (ret)
827 mlog_errno(ret); 852 mlog_errno(ret);
828 else 853 else
829 ocfs2_dentry_unlock(dentry, 1); 854 ocfs2_dentry_unlock(dentry, 1);
830 855
831 return ret; 856 return ret;
832 } 857 }
833 858
834 static inline int ocfs2_inode_is_unlinkable(struct inode *inode) 859 static inline int ocfs2_inode_is_unlinkable(struct inode *inode)
835 { 860 {
836 if (S_ISDIR(inode->i_mode)) { 861 if (S_ISDIR(inode->i_mode)) {
837 if (inode->i_nlink == 2) 862 if (inode->i_nlink == 2)
838 return 1; 863 return 1;
839 return 0; 864 return 0;
840 } 865 }
841 866
842 if (inode->i_nlink == 1) 867 if (inode->i_nlink == 1)
843 return 1; 868 return 1;
844 return 0; 869 return 0;
845 } 870 }
846 871
847 static int ocfs2_unlink(struct inode *dir, 872 static int ocfs2_unlink(struct inode *dir,
848 struct dentry *dentry) 873 struct dentry *dentry)
849 { 874 {
850 int status; 875 int status;
851 int child_locked = 0; 876 int child_locked = 0;
852 bool is_unlinkable = false; 877 bool is_unlinkable = false;
853 struct inode *inode = dentry->d_inode; 878 struct inode *inode = dentry->d_inode;
854 struct inode *orphan_dir = NULL; 879 struct inode *orphan_dir = NULL;
855 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 880 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
856 u64 blkno; 881 u64 blkno;
857 struct ocfs2_dinode *fe = NULL; 882 struct ocfs2_dinode *fe = NULL;
858 struct buffer_head *fe_bh = NULL; 883 struct buffer_head *fe_bh = NULL;
859 struct buffer_head *parent_node_bh = NULL; 884 struct buffer_head *parent_node_bh = NULL;
860 handle_t *handle = NULL; 885 handle_t *handle = NULL;
861 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; 886 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
862 struct ocfs2_dir_lookup_result lookup = { NULL, }; 887 struct ocfs2_dir_lookup_result lookup = { NULL, };
863 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 888 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
864 889
865 trace_ocfs2_unlink(dir, dentry, dentry->d_name.len, 890 trace_ocfs2_unlink(dir, dentry, dentry->d_name.len,
866 dentry->d_name.name, 891 dentry->d_name.name,
867 (unsigned long long)OCFS2_I(dir)->ip_blkno, 892 (unsigned long long)OCFS2_I(dir)->ip_blkno,
868 (unsigned long long)OCFS2_I(inode)->ip_blkno); 893 (unsigned long long)OCFS2_I(inode)->ip_blkno);
869 894
870 dquot_initialize(dir); 895 dquot_initialize(dir);
871 896
872 BUG_ON(dentry->d_parent->d_inode != dir); 897 BUG_ON(dentry->d_parent->d_inode != dir);
873 898
874 if (inode == osb->root_inode) 899 if (inode == osb->root_inode)
875 return -EPERM; 900 return -EPERM;
876 901
877 status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1, 902 status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1,
878 OI_LS_PARENT); 903 OI_LS_PARENT);
879 if (status < 0) { 904 if (status < 0) {
880 if (status != -ENOENT) 905 if (status != -ENOENT)
881 mlog_errno(status); 906 mlog_errno(status);
882 return status; 907 return status;
883 } 908 }
884 909
885 status = ocfs2_find_files_on_disk(dentry->d_name.name, 910 status = ocfs2_find_files_on_disk(dentry->d_name.name,
886 dentry->d_name.len, &blkno, dir, 911 dentry->d_name.len, &blkno, dir,
887 &lookup); 912 &lookup);
888 if (status < 0) { 913 if (status < 0) {
889 if (status != -ENOENT) 914 if (status != -ENOENT)
890 mlog_errno(status); 915 mlog_errno(status);
891 goto leave; 916 goto leave;
892 } 917 }
893 918
894 if (OCFS2_I(inode)->ip_blkno != blkno) { 919 if (OCFS2_I(inode)->ip_blkno != blkno) {
895 status = -ENOENT; 920 status = -ENOENT;
896 921
897 trace_ocfs2_unlink_noent( 922 trace_ocfs2_unlink_noent(
898 (unsigned long long)OCFS2_I(inode)->ip_blkno, 923 (unsigned long long)OCFS2_I(inode)->ip_blkno,
899 (unsigned long long)blkno, 924 (unsigned long long)blkno,
900 OCFS2_I(inode)->ip_flags); 925 OCFS2_I(inode)->ip_flags);
901 goto leave; 926 goto leave;
902 } 927 }
903 928
904 status = ocfs2_inode_lock(inode, &fe_bh, 1); 929 status = ocfs2_inode_lock(inode, &fe_bh, 1);
905 if (status < 0) { 930 if (status < 0) {
906 if (status != -ENOENT) 931 if (status != -ENOENT)
907 mlog_errno(status); 932 mlog_errno(status);
908 goto leave; 933 goto leave;
909 } 934 }
910 child_locked = 1; 935 child_locked = 1;
911 936
912 if (S_ISDIR(inode->i_mode)) { 937 if (S_ISDIR(inode->i_mode)) {
913 if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) { 938 if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) {
914 status = -ENOTEMPTY; 939 status = -ENOTEMPTY;
915 goto leave; 940 goto leave;
916 } 941 }
917 } 942 }
918 943
919 status = ocfs2_remote_dentry_delete(dentry); 944 status = ocfs2_remote_dentry_delete(dentry);
920 if (status < 0) { 945 if (status < 0) {
921 /* This remote delete should succeed under all normal 946 /* This remote delete should succeed under all normal
922 * circumstances. */ 947 * circumstances. */
923 mlog_errno(status); 948 mlog_errno(status);
924 goto leave; 949 goto leave;
925 } 950 }
926 951
927 if (ocfs2_inode_is_unlinkable(inode)) { 952 if (ocfs2_inode_is_unlinkable(inode)) {
928 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, 953 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
929 OCFS2_I(inode)->ip_blkno, 954 OCFS2_I(inode)->ip_blkno,
930 orphan_name, &orphan_insert); 955 orphan_name, &orphan_insert);
931 if (status < 0) { 956 if (status < 0) {
932 mlog_errno(status); 957 mlog_errno(status);
933 goto leave; 958 goto leave;
934 } 959 }
935 is_unlinkable = true; 960 is_unlinkable = true;
936 } 961 }
937 962
938 handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb)); 963 handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb));
939 if (IS_ERR(handle)) { 964 if (IS_ERR(handle)) {
940 status = PTR_ERR(handle); 965 status = PTR_ERR(handle);
941 handle = NULL; 966 handle = NULL;
942 mlog_errno(status); 967 mlog_errno(status);
943 goto leave; 968 goto leave;
944 } 969 }
945 970
946 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh, 971 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
947 OCFS2_JOURNAL_ACCESS_WRITE); 972 OCFS2_JOURNAL_ACCESS_WRITE);
948 if (status < 0) { 973 if (status < 0) {
949 mlog_errno(status); 974 mlog_errno(status);
950 goto leave; 975 goto leave;
951 } 976 }
952 977
953 fe = (struct ocfs2_dinode *) fe_bh->b_data; 978 fe = (struct ocfs2_dinode *) fe_bh->b_data;
954 979
955 /* delete the name from the parent dir */ 980 /* delete the name from the parent dir */
956 status = ocfs2_delete_entry(handle, dir, &lookup); 981 status = ocfs2_delete_entry(handle, dir, &lookup);
957 if (status < 0) { 982 if (status < 0) {
958 mlog_errno(status); 983 mlog_errno(status);
959 goto leave; 984 goto leave;
960 } 985 }
961 986
962 if (S_ISDIR(inode->i_mode)) 987 if (S_ISDIR(inode->i_mode))
963 drop_nlink(inode); 988 drop_nlink(inode);
964 drop_nlink(inode); 989 drop_nlink(inode);
965 ocfs2_set_links_count(fe, inode->i_nlink); 990 ocfs2_set_links_count(fe, inode->i_nlink);
966 ocfs2_journal_dirty(handle, fe_bh); 991 ocfs2_journal_dirty(handle, fe_bh);
967 992
968 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 993 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
969 if (S_ISDIR(inode->i_mode)) 994 if (S_ISDIR(inode->i_mode))
970 drop_nlink(dir); 995 drop_nlink(dir);
971 996
972 status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh); 997 status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
973 if (status < 0) { 998 if (status < 0) {
974 mlog_errno(status); 999 mlog_errno(status);
975 if (S_ISDIR(inode->i_mode)) 1000 if (S_ISDIR(inode->i_mode))
976 inc_nlink(dir); 1001 inc_nlink(dir);
977 goto leave; 1002 goto leave;
978 } 1003 }
979 1004
980 if (is_unlinkable) { 1005 if (is_unlinkable) {
981 status = ocfs2_orphan_add(osb, handle, inode, fe_bh, 1006 status = ocfs2_orphan_add(osb, handle, inode, fe_bh,
982 orphan_name, &orphan_insert, orphan_dir); 1007 orphan_name, &orphan_insert, orphan_dir);
983 if (status < 0) 1008 if (status < 0)
984 mlog_errno(status); 1009 mlog_errno(status);
985 } 1010 }
986 1011
987 leave: 1012 leave:
988 if (handle) 1013 if (handle)
989 ocfs2_commit_trans(osb, handle); 1014 ocfs2_commit_trans(osb, handle);
990 1015
991 if (child_locked) 1016 if (child_locked)
992 ocfs2_inode_unlock(inode, 1); 1017 ocfs2_inode_unlock(inode, 1);
993 1018
994 ocfs2_inode_unlock(dir, 1); 1019 ocfs2_inode_unlock(dir, 1);
995 1020
996 if (orphan_dir) { 1021 if (orphan_dir) {
997 /* This was locked for us in ocfs2_prepare_orphan_dir() */ 1022 /* This was locked for us in ocfs2_prepare_orphan_dir() */
998 ocfs2_inode_unlock(orphan_dir, 1); 1023 ocfs2_inode_unlock(orphan_dir, 1);
999 mutex_unlock(&orphan_dir->i_mutex); 1024 mutex_unlock(&orphan_dir->i_mutex);
1000 iput(orphan_dir); 1025 iput(orphan_dir);
1001 } 1026 }
1002 1027
1003 brelse(fe_bh); 1028 brelse(fe_bh);
1004 brelse(parent_node_bh); 1029 brelse(parent_node_bh);
1005 1030
1006 ocfs2_free_dir_lookup_result(&orphan_insert); 1031 ocfs2_free_dir_lookup_result(&orphan_insert);
1007 ocfs2_free_dir_lookup_result(&lookup); 1032 ocfs2_free_dir_lookup_result(&lookup);
1008 1033
1009 if (status && (status != -ENOTEMPTY) && (status != -ENOENT)) 1034 if (status && (status != -ENOTEMPTY) && (status != -ENOENT))
1010 mlog_errno(status); 1035 mlog_errno(status);
1011 1036
1012 return status; 1037 return status;
1013 } 1038 }
1014 1039
1015 static int ocfs2_check_if_ancestor(struct ocfs2_super *osb, 1040 static int ocfs2_check_if_ancestor(struct ocfs2_super *osb,
1016 u64 src_inode_no, u64 dest_inode_no) 1041 u64 src_inode_no, u64 dest_inode_no)
1017 { 1042 {
1018 int ret = 0, i = 0; 1043 int ret = 0, i = 0;
1019 u64 parent_inode_no = 0; 1044 u64 parent_inode_no = 0;
1020 u64 child_inode_no = src_inode_no; 1045 u64 child_inode_no = src_inode_no;
1021 struct inode *child_inode; 1046 struct inode *child_inode;
1022 1047
1023 #define MAX_LOOKUP_TIMES 32 1048 #define MAX_LOOKUP_TIMES 32
1024 while (1) { 1049 while (1) {
1025 child_inode = ocfs2_iget(osb, child_inode_no, 0, 0); 1050 child_inode = ocfs2_iget(osb, child_inode_no, 0, 0);
1026 if (IS_ERR(child_inode)) { 1051 if (IS_ERR(child_inode)) {
1027 ret = PTR_ERR(child_inode); 1052 ret = PTR_ERR(child_inode);
1028 break; 1053 break;
1029 } 1054 }
1030 1055
1031 ret = ocfs2_inode_lock(child_inode, NULL, 0); 1056 ret = ocfs2_inode_lock(child_inode, NULL, 0);
1032 if (ret < 0) { 1057 if (ret < 0) {
1033 iput(child_inode); 1058 iput(child_inode);
1034 if (ret != -ENOENT) 1059 if (ret != -ENOENT)
1035 mlog_errno(ret); 1060 mlog_errno(ret);
1036 break; 1061 break;
1037 } 1062 }
1038 1063
1039 ret = ocfs2_lookup_ino_from_name(child_inode, "..", 2, 1064 ret = ocfs2_lookup_ino_from_name(child_inode, "..", 2,
1040 &parent_inode_no); 1065 &parent_inode_no);
1041 ocfs2_inode_unlock(child_inode, 0); 1066 ocfs2_inode_unlock(child_inode, 0);
1042 iput(child_inode); 1067 iput(child_inode);
1043 if (ret < 0) { 1068 if (ret < 0) {
1044 ret = -ENOENT; 1069 ret = -ENOENT;
1045 break; 1070 break;
1046 } 1071 }
1047 1072
1048 if (parent_inode_no == dest_inode_no) { 1073 if (parent_inode_no == dest_inode_no) {
1049 ret = 1; 1074 ret = 1;
1050 break; 1075 break;
1051 } 1076 }
1052 1077
1053 if (parent_inode_no == osb->root_inode->i_ino) { 1078 if (parent_inode_no == osb->root_inode->i_ino) {
1054 ret = 0; 1079 ret = 0;
1055 break; 1080 break;
1056 } 1081 }
1057 1082
1058 child_inode_no = parent_inode_no; 1083 child_inode_no = parent_inode_no;
1059 1084
1060 if (++i >= MAX_LOOKUP_TIMES) { 1085 if (++i >= MAX_LOOKUP_TIMES) {
1061 mlog(ML_NOTICE, "max lookup times reached, filesystem " 1086 mlog(ML_NOTICE, "max lookup times reached, filesystem "
1062 "may have nested directories, " 1087 "may have nested directories, "
1063 "src inode: %llu, dest inode: %llu.\n", 1088 "src inode: %llu, dest inode: %llu.\n",
1064 (unsigned long long)src_inode_no, 1089 (unsigned long long)src_inode_no,
1065 (unsigned long long)dest_inode_no); 1090 (unsigned long long)dest_inode_no);
1066 ret = 0; 1091 ret = 0;
1067 break; 1092 break;
1068 } 1093 }
1069 } 1094 }
1070 1095
1071 return ret; 1096 return ret;
1072 } 1097 }
1073 1098
1074 /* 1099 /*
1075 * The only place this should be used is rename! 1100 * The only place this should be used is rename and link!
1076 * if they have the same id, then the 1st one is the only one locked. 1101 * if they have the same id, then the 1st one is the only one locked.
1077 */ 1102 */
1078 static int ocfs2_double_lock(struct ocfs2_super *osb, 1103 static int ocfs2_double_lock(struct ocfs2_super *osb,
1079 struct buffer_head **bh1, 1104 struct buffer_head **bh1,
1080 struct inode *inode1, 1105 struct inode *inode1,
1081 struct buffer_head **bh2, 1106 struct buffer_head **bh2,
1082 struct inode *inode2) 1107 struct inode *inode2,
1108 int rename)
1083 { 1109 {
1084 int status; 1110 int status;
1085 int inode1_is_ancestor, inode2_is_ancestor; 1111 int inode1_is_ancestor, inode2_is_ancestor;
1086 struct ocfs2_inode_info *oi1 = OCFS2_I(inode1); 1112 struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
1087 struct ocfs2_inode_info *oi2 = OCFS2_I(inode2); 1113 struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
1088 struct buffer_head **tmpbh; 1114 struct buffer_head **tmpbh;
1089 struct inode *tmpinode; 1115 struct inode *tmpinode;
1090 1116
1091 trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno, 1117 trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno,
1092 (unsigned long long)oi2->ip_blkno); 1118 (unsigned long long)oi2->ip_blkno);
1093 1119
1094 if (*bh1) 1120 if (*bh1)
1095 *bh1 = NULL; 1121 *bh1 = NULL;
1096 if (*bh2) 1122 if (*bh2)
1097 *bh2 = NULL; 1123 *bh2 = NULL;
1098 1124
1099 /* we always want to lock the one with the lower lockid first. 1125 /* we always want to lock the one with the lower lockid first.
1100 * and if they are nested, we lock ancestor first */ 1126 * and if they are nested, we lock ancestor first */
1101 if (oi1->ip_blkno != oi2->ip_blkno) { 1127 if (oi1->ip_blkno != oi2->ip_blkno) {
1102 inode1_is_ancestor = ocfs2_check_if_ancestor(osb, oi2->ip_blkno, 1128 inode1_is_ancestor = ocfs2_check_if_ancestor(osb, oi2->ip_blkno,
1103 oi1->ip_blkno); 1129 oi1->ip_blkno);
1104 if (inode1_is_ancestor < 0) { 1130 if (inode1_is_ancestor < 0) {
1105 status = inode1_is_ancestor; 1131 status = inode1_is_ancestor;
1106 goto bail; 1132 goto bail;
1107 } 1133 }
1108 1134
1109 inode2_is_ancestor = ocfs2_check_if_ancestor(osb, oi1->ip_blkno, 1135 inode2_is_ancestor = ocfs2_check_if_ancestor(osb, oi1->ip_blkno,
1110 oi2->ip_blkno); 1136 oi2->ip_blkno);
1111 if (inode2_is_ancestor < 0) { 1137 if (inode2_is_ancestor < 0) {
1112 status = inode2_is_ancestor; 1138 status = inode2_is_ancestor;
1113 goto bail; 1139 goto bail;
1114 } 1140 }
1115 1141
1116 if ((inode1_is_ancestor == 1) || 1142 if ((inode1_is_ancestor == 1) ||
1117 (oi1->ip_blkno < oi2->ip_blkno && 1143 (oi1->ip_blkno < oi2->ip_blkno &&
1118 inode2_is_ancestor == 0)) { 1144 inode2_is_ancestor == 0)) {
1119 /* switch id1 and id2 around */ 1145 /* switch id1 and id2 around */
1120 tmpbh = bh2; 1146 tmpbh = bh2;
1121 bh2 = bh1; 1147 bh2 = bh1;
1122 bh1 = tmpbh; 1148 bh1 = tmpbh;
1123 1149
1124 tmpinode = inode2; 1150 tmpinode = inode2;
1125 inode2 = inode1; 1151 inode2 = inode1;
1126 inode1 = tmpinode; 1152 inode1 = tmpinode;
1127 } 1153 }
1128 /* lock id2 */ 1154 /* lock id2 */
1129 status = ocfs2_inode_lock_nested(inode2, bh2, 1, 1155 status = ocfs2_inode_lock_nested(inode2, bh2, 1,
1130 OI_LS_RENAME1); 1156 rename == 1 ? OI_LS_RENAME1 : OI_LS_PARENT);
1131 if (status < 0) { 1157 if (status < 0) {
1132 if (status != -ENOENT) 1158 if (status != -ENOENT)
1133 mlog_errno(status); 1159 mlog_errno(status);
1134 goto bail; 1160 goto bail;
1135 } 1161 }
1136 } 1162 }
1137 1163
1138 /* lock id1 */ 1164 /* lock id1 */
1139 status = ocfs2_inode_lock_nested(inode1, bh1, 1, OI_LS_RENAME2); 1165 status = ocfs2_inode_lock_nested(inode1, bh1, 1,
1166 rename == 1 ? OI_LS_RENAME2 : OI_LS_PARENT);
1140 if (status < 0) { 1167 if (status < 0) {
1141 /* 1168 /*
1142 * An error return must mean that no cluster locks 1169 * An error return must mean that no cluster locks
1143 * were held on function exit. 1170 * were held on function exit.
1144 */ 1171 */
1145 if (oi1->ip_blkno != oi2->ip_blkno) { 1172 if (oi1->ip_blkno != oi2->ip_blkno) {
1146 ocfs2_inode_unlock(inode2, 1); 1173 ocfs2_inode_unlock(inode2, 1);
1147 brelse(*bh2); 1174 brelse(*bh2);
1148 *bh2 = NULL; 1175 *bh2 = NULL;
1149 } 1176 }
1150 1177
1151 if (status != -ENOENT) 1178 if (status != -ENOENT)
1152 mlog_errno(status); 1179 mlog_errno(status);
1153 } 1180 }
1154 1181
1155 trace_ocfs2_double_lock_end( 1182 trace_ocfs2_double_lock_end(
1156 (unsigned long long)OCFS2_I(inode1)->ip_blkno, 1183 (unsigned long long)OCFS2_I(inode1)->ip_blkno,
1157 (unsigned long long)OCFS2_I(inode2)->ip_blkno); 1184 (unsigned long long)OCFS2_I(inode2)->ip_blkno);
1158 1185
1159 bail: 1186 bail:
1160 if (status) 1187 if (status)
1161 mlog_errno(status); 1188 mlog_errno(status);
1162 return status; 1189 return status;
1163 } 1190 }
1164 1191
1165 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2) 1192 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
1166 { 1193 {
1167 ocfs2_inode_unlock(inode1, 1); 1194 ocfs2_inode_unlock(inode1, 1);
1168 1195
1169 if (inode1 != inode2) 1196 if (inode1 != inode2)
1170 ocfs2_inode_unlock(inode2, 1); 1197 ocfs2_inode_unlock(inode2, 1);
1171 } 1198 }
1172 1199
1173 static int ocfs2_rename(struct inode *old_dir, 1200 static int ocfs2_rename(struct inode *old_dir,
1174 struct dentry *old_dentry, 1201 struct dentry *old_dentry,
1175 struct inode *new_dir, 1202 struct inode *new_dir,
1176 struct dentry *new_dentry) 1203 struct dentry *new_dentry)
1177 { 1204 {
1178 int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0; 1205 int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
1179 int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0; 1206 int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
1180 struct inode *old_inode = old_dentry->d_inode; 1207 struct inode *old_inode = old_dentry->d_inode;
1181 struct inode *new_inode = new_dentry->d_inode; 1208 struct inode *new_inode = new_dentry->d_inode;
1182 struct inode *orphan_dir = NULL; 1209 struct inode *orphan_dir = NULL;
1183 struct ocfs2_dinode *newfe = NULL; 1210 struct ocfs2_dinode *newfe = NULL;
1184 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; 1211 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
1185 struct buffer_head *newfe_bh = NULL; 1212 struct buffer_head *newfe_bh = NULL;
1186 struct buffer_head *old_inode_bh = NULL; 1213 struct buffer_head *old_inode_bh = NULL;
1187 struct ocfs2_super *osb = NULL; 1214 struct ocfs2_super *osb = NULL;
1188 u64 newfe_blkno, old_de_ino; 1215 u64 newfe_blkno, old_de_ino;
1189 handle_t *handle = NULL; 1216 handle_t *handle = NULL;
1190 struct buffer_head *old_dir_bh = NULL; 1217 struct buffer_head *old_dir_bh = NULL;
1191 struct buffer_head *new_dir_bh = NULL; 1218 struct buffer_head *new_dir_bh = NULL;
1192 u32 old_dir_nlink = old_dir->i_nlink; 1219 u32 old_dir_nlink = old_dir->i_nlink;
1193 struct ocfs2_dinode *old_di; 1220 struct ocfs2_dinode *old_di;
1194 struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, }; 1221 struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, };
1195 struct ocfs2_dir_lookup_result target_lookup_res = { NULL, }; 1222 struct ocfs2_dir_lookup_result target_lookup_res = { NULL, };
1196 struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, }; 1223 struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, };
1197 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 1224 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
1198 struct ocfs2_dir_lookup_result target_insert = { NULL, }; 1225 struct ocfs2_dir_lookup_result target_insert = { NULL, };
1199 bool should_add_orphan = false; 1226 bool should_add_orphan = false;
1200 1227
1201 /* At some point it might be nice to break this function up a 1228 /* At some point it might be nice to break this function up a
1202 * bit. */ 1229 * bit. */
1203 1230
1204 trace_ocfs2_rename(old_dir, old_dentry, new_dir, new_dentry, 1231 trace_ocfs2_rename(old_dir, old_dentry, new_dir, new_dentry,
1205 old_dentry->d_name.len, old_dentry->d_name.name, 1232 old_dentry->d_name.len, old_dentry->d_name.name,
1206 new_dentry->d_name.len, new_dentry->d_name.name); 1233 new_dentry->d_name.len, new_dentry->d_name.name);
1207 1234
1208 dquot_initialize(old_dir); 1235 dquot_initialize(old_dir);
1209 dquot_initialize(new_dir); 1236 dquot_initialize(new_dir);
1210 1237
1211 osb = OCFS2_SB(old_dir->i_sb); 1238 osb = OCFS2_SB(old_dir->i_sb);
1212 1239
1213 if (new_inode) { 1240 if (new_inode) {
1214 if (!igrab(new_inode)) 1241 if (!igrab(new_inode))
1215 BUG(); 1242 BUG();
1216 } 1243 }
1217 1244
1218 /* Assume a directory hierarchy thusly: 1245 /* Assume a directory hierarchy thusly:
1219 * a/b/c 1246 * a/b/c
1220 * a/d 1247 * a/d
1221 * a,b,c, and d are all directories. 1248 * a,b,c, and d are all directories.
1222 * 1249 *
1223 * from cwd of 'a' on both nodes: 1250 * from cwd of 'a' on both nodes:
1224 * node1: mv b/c d 1251 * node1: mv b/c d
1225 * node2: mv d b/c 1252 * node2: mv d b/c
1226 * 1253 *
1227 * And that's why, just like the VFS, we need a file system 1254 * And that's why, just like the VFS, we need a file system
1228 * rename lock. */ 1255 * rename lock. */
1229 if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) { 1256 if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1230 status = ocfs2_rename_lock(osb); 1257 status = ocfs2_rename_lock(osb);
1231 if (status < 0) { 1258 if (status < 0) {
1232 mlog_errno(status); 1259 mlog_errno(status);
1233 goto bail; 1260 goto bail;
1234 } 1261 }
1235 rename_lock = 1; 1262 rename_lock = 1;
1236 1263
1237 /* here we cannot guarantee the inodes haven't just been 1264 /* here we cannot guarantee the inodes haven't just been
1238 * changed, so check if they are nested again */ 1265 * changed, so check if they are nested again */
1239 status = ocfs2_check_if_ancestor(osb, new_dir->i_ino, 1266 status = ocfs2_check_if_ancestor(osb, new_dir->i_ino,
1240 old_inode->i_ino); 1267 old_inode->i_ino);
1241 if (status < 0) { 1268 if (status < 0) {
1242 mlog_errno(status); 1269 mlog_errno(status);
1243 goto bail; 1270 goto bail;
1244 } else if (status == 1) { 1271 } else if (status == 1) {
1245 status = -EPERM; 1272 status = -EPERM;
1246 trace_ocfs2_rename_not_permitted( 1273 trace_ocfs2_rename_not_permitted(
1247 (unsigned long long)old_inode->i_ino, 1274 (unsigned long long)old_inode->i_ino,
1248 (unsigned long long)new_dir->i_ino); 1275 (unsigned long long)new_dir->i_ino);
1249 goto bail; 1276 goto bail;
1250 } 1277 }
1251 } 1278 }
1252 1279
1253 /* if old and new are the same, this'll just do one lock. */ 1280 /* if old and new are the same, this'll just do one lock. */
1254 status = ocfs2_double_lock(osb, &old_dir_bh, old_dir, 1281 status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1255 &new_dir_bh, new_dir); 1282 &new_dir_bh, new_dir, 1);
1256 if (status < 0) { 1283 if (status < 0) {
1257 mlog_errno(status); 1284 mlog_errno(status);
1258 goto bail; 1285 goto bail;
1259 } 1286 }
1260 parents_locked = 1; 1287 parents_locked = 1;
1261 1288
1262 /* make sure both dirs have bhs 1289 /* make sure both dirs have bhs
1263 * get an extra ref on old_dir_bh if old==new */ 1290 * get an extra ref on old_dir_bh if old==new */
1264 if (!new_dir_bh) { 1291 if (!new_dir_bh) {
1265 if (old_dir_bh) { 1292 if (old_dir_bh) {
1266 new_dir_bh = old_dir_bh; 1293 new_dir_bh = old_dir_bh;
1267 get_bh(new_dir_bh); 1294 get_bh(new_dir_bh);
1268 } else { 1295 } else {
1269 mlog(ML_ERROR, "no old_dir_bh!\n"); 1296 mlog(ML_ERROR, "no old_dir_bh!\n");
1270 status = -EIO; 1297 status = -EIO;
1271 goto bail; 1298 goto bail;
1272 } 1299 }
1273 } 1300 }
1274 1301
1275 /* 1302 /*
1276 * Aside from allowing a meta data update, the locking here 1303 * Aside from allowing a meta data update, the locking here
1277 * also ensures that the downconvert thread on other nodes 1304 * also ensures that the downconvert thread on other nodes
1278 * won't have to concurrently downconvert the inode and the 1305 * won't have to concurrently downconvert the inode and the
1279 * dentry locks. 1306 * dentry locks.
1280 */ 1307 */
1281 status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1, 1308 status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1,
1282 OI_LS_PARENT); 1309 OI_LS_PARENT);
1283 if (status < 0) { 1310 if (status < 0) {
1284 if (status != -ENOENT) 1311 if (status != -ENOENT)
1285 mlog_errno(status); 1312 mlog_errno(status);
1286 goto bail; 1313 goto bail;
1287 } 1314 }
1288 old_child_locked = 1; 1315 old_child_locked = 1;
1289 1316
1290 status = ocfs2_remote_dentry_delete(old_dentry); 1317 status = ocfs2_remote_dentry_delete(old_dentry);
1291 if (status < 0) { 1318 if (status < 0) {
1292 mlog_errno(status); 1319 mlog_errno(status);
1293 goto bail; 1320 goto bail;
1294 } 1321 }
1295 1322
1296 if (S_ISDIR(old_inode->i_mode)) { 1323 if (S_ISDIR(old_inode->i_mode)) {
1297 u64 old_inode_parent; 1324 u64 old_inode_parent;
1298 1325
1299 update_dot_dot = 1; 1326 update_dot_dot = 1;
1300 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent, 1327 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1301 old_inode, 1328 old_inode,
1302 &old_inode_dot_dot_res); 1329 &old_inode_dot_dot_res);
1303 if (status) { 1330 if (status) {
1304 status = -EIO; 1331 status = -EIO;
1305 goto bail; 1332 goto bail;
1306 } 1333 }
1307 1334
1308 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) { 1335 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1309 status = -EIO; 1336 status = -EIO;
1310 goto bail; 1337 goto bail;
1311 } 1338 }
1312 1339
1313 if (!new_inode && new_dir != old_dir && 1340 if (!new_inode && new_dir != old_dir &&
1314 new_dir->i_nlink >= ocfs2_link_max(osb)) { 1341 new_dir->i_nlink >= ocfs2_link_max(osb)) {
1315 status = -EMLINK; 1342 status = -EMLINK;
1316 goto bail; 1343 goto bail;
1317 } 1344 }
1318 } 1345 }
1319 1346
1320 status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name, 1347 status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1321 old_dentry->d_name.len, 1348 old_dentry->d_name.len,
1322 &old_de_ino); 1349 &old_de_ino);
1323 if (status) { 1350 if (status) {
1324 status = -ENOENT; 1351 status = -ENOENT;
1325 goto bail; 1352 goto bail;
1326 } 1353 }
1327 1354
1328 /* 1355 /*
1329 * Check for inode number is _not_ due to possible IO errors. 1356 * Check for inode number is _not_ due to possible IO errors.
1330 * We might rmdir the source, keep it as pwd of some process 1357 * We might rmdir the source, keep it as pwd of some process
1331 * and merrily kill the link to whatever was created under the 1358 * and merrily kill the link to whatever was created under the
1332 * same name. Goodbye sticky bit ;-< 1359 * same name. Goodbye sticky bit ;-<
1333 */ 1360 */
1334 if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) { 1361 if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1335 status = -ENOENT; 1362 status = -ENOENT;
1336 goto bail; 1363 goto bail;
1337 } 1364 }
1338 1365
1339 /* check if the target already exists (in which case we need 1366 /* check if the target already exists (in which case we need
1340 * to delete it */ 1367 * to delete it */
1341 status = ocfs2_find_files_on_disk(new_dentry->d_name.name, 1368 status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1342 new_dentry->d_name.len, 1369 new_dentry->d_name.len,
1343 &newfe_blkno, new_dir, 1370 &newfe_blkno, new_dir,
1344 &target_lookup_res); 1371 &target_lookup_res);
1345 /* The only error we allow here is -ENOENT because the new 1372 /* The only error we allow here is -ENOENT because the new
1346 * file not existing is perfectly valid. */ 1373 * file not existing is perfectly valid. */
1347 if ((status < 0) && (status != -ENOENT)) { 1374 if ((status < 0) && (status != -ENOENT)) {
1348 /* If we cannot find the file specified we should just */ 1375 /* If we cannot find the file specified we should just */
1349 /* return the error... */ 1376 /* return the error... */
1350 mlog_errno(status); 1377 mlog_errno(status);
1351 goto bail; 1378 goto bail;
1352 } 1379 }
1353 if (status == 0) 1380 if (status == 0)
1354 target_exists = 1; 1381 target_exists = 1;
1355 1382
1356 if (!target_exists && new_inode) { 1383 if (!target_exists && new_inode) {
1357 /* 1384 /*
1358 * Target was unlinked by another node while we were 1385 * Target was unlinked by another node while we were
1359 * waiting to get to ocfs2_rename(). There isn't 1386 * waiting to get to ocfs2_rename(). There isn't
1360 * anything we can do here to help the situation, so 1387 * anything we can do here to help the situation, so
1361 * bubble up the appropriate error. 1388 * bubble up the appropriate error.
1362 */ 1389 */
1363 status = -ENOENT; 1390 status = -ENOENT;
1364 goto bail; 1391 goto bail;
1365 } 1392 }
1366 1393
1367 /* In case we need to overwrite an existing file, we blow it 1394 /* In case we need to overwrite an existing file, we blow it
1368 * away first */ 1395 * away first */
1369 if (target_exists) { 1396 if (target_exists) {
1370 /* VFS didn't think there existed an inode here, but 1397 /* VFS didn't think there existed an inode here, but
1371 * someone else in the cluster must have raced our 1398 * someone else in the cluster must have raced our
1372 * rename to create one. Today we error cleanly, in 1399 * rename to create one. Today we error cleanly, in
1373 * the future we should consider calling iget to build 1400 * the future we should consider calling iget to build
1374 * a new struct inode for this entry. */ 1401 * a new struct inode for this entry. */
1375 if (!new_inode) { 1402 if (!new_inode) {
1376 status = -EACCES; 1403 status = -EACCES;
1377 1404
1378 trace_ocfs2_rename_target_exists(new_dentry->d_name.len, 1405 trace_ocfs2_rename_target_exists(new_dentry->d_name.len,
1379 new_dentry->d_name.name); 1406 new_dentry->d_name.name);
1380 goto bail; 1407 goto bail;
1381 } 1408 }
1382 1409
1383 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) { 1410 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1384 status = -EACCES; 1411 status = -EACCES;
1385 1412
1386 trace_ocfs2_rename_disagree( 1413 trace_ocfs2_rename_disagree(
1387 (unsigned long long)OCFS2_I(new_inode)->ip_blkno, 1414 (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1388 (unsigned long long)newfe_blkno, 1415 (unsigned long long)newfe_blkno,
1389 OCFS2_I(new_inode)->ip_flags); 1416 OCFS2_I(new_inode)->ip_flags);
1390 goto bail; 1417 goto bail;
1391 } 1418 }
1392 1419
1393 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1); 1420 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1394 if (status < 0) { 1421 if (status < 0) {
1395 if (status != -ENOENT) 1422 if (status != -ENOENT)
1396 mlog_errno(status); 1423 mlog_errno(status);
1397 goto bail; 1424 goto bail;
1398 } 1425 }
1399 new_child_locked = 1; 1426 new_child_locked = 1;
1400 1427
1401 status = ocfs2_remote_dentry_delete(new_dentry); 1428 status = ocfs2_remote_dentry_delete(new_dentry);
1402 if (status < 0) { 1429 if (status < 0) {
1403 mlog_errno(status); 1430 mlog_errno(status);
1404 goto bail; 1431 goto bail;
1405 } 1432 }
1406 1433
1407 newfe = (struct ocfs2_dinode *) newfe_bh->b_data; 1434 newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1408 1435
1409 trace_ocfs2_rename_over_existing( 1436 trace_ocfs2_rename_over_existing(
1410 (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ? 1437 (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1411 (unsigned long long)newfe_bh->b_blocknr : 0ULL); 1438 (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1412 1439
1413 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) { 1440 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1414 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, 1441 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1415 OCFS2_I(new_inode)->ip_blkno, 1442 OCFS2_I(new_inode)->ip_blkno,
1416 orphan_name, &orphan_insert); 1443 orphan_name, &orphan_insert);
1417 if (status < 0) { 1444 if (status < 0) {
1418 mlog_errno(status); 1445 mlog_errno(status);
1419 goto bail; 1446 goto bail;
1420 } 1447 }
1421 should_add_orphan = true; 1448 should_add_orphan = true;
1422 } 1449 }
1423 } else { 1450 } else {
1424 BUG_ON(new_dentry->d_parent->d_inode != new_dir); 1451 BUG_ON(new_dentry->d_parent->d_inode != new_dir);
1425 1452
1426 status = ocfs2_check_dir_for_entry(new_dir, 1453 status = ocfs2_check_dir_for_entry(new_dir,
1427 new_dentry->d_name.name, 1454 new_dentry->d_name.name,
1428 new_dentry->d_name.len); 1455 new_dentry->d_name.len);
1429 if (status) 1456 if (status)
1430 goto bail; 1457 goto bail;
1431 1458
1432 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh, 1459 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1433 new_dentry->d_name.name, 1460 new_dentry->d_name.name,
1434 new_dentry->d_name.len, 1461 new_dentry->d_name.len,
1435 &target_insert); 1462 &target_insert);
1436 if (status < 0) { 1463 if (status < 0) {
1437 mlog_errno(status); 1464 mlog_errno(status);
1438 goto bail; 1465 goto bail;
1439 } 1466 }
1440 } 1467 }
1441 1468
1442 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb)); 1469 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
1443 if (IS_ERR(handle)) { 1470 if (IS_ERR(handle)) {
1444 status = PTR_ERR(handle); 1471 status = PTR_ERR(handle);
1445 handle = NULL; 1472 handle = NULL;
1446 mlog_errno(status); 1473 mlog_errno(status);
1447 goto bail; 1474 goto bail;
1448 } 1475 }
1449 1476
1450 if (target_exists) { 1477 if (target_exists) {
1451 if (S_ISDIR(new_inode->i_mode)) { 1478 if (S_ISDIR(new_inode->i_mode)) {
1452 if (new_inode->i_nlink != 2 || 1479 if (new_inode->i_nlink != 2 ||
1453 !ocfs2_empty_dir(new_inode)) { 1480 !ocfs2_empty_dir(new_inode)) {
1454 status = -ENOTEMPTY; 1481 status = -ENOTEMPTY;
1455 goto bail; 1482 goto bail;
1456 } 1483 }
1457 } 1484 }
1458 status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode), 1485 status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode),
1459 newfe_bh, 1486 newfe_bh,
1460 OCFS2_JOURNAL_ACCESS_WRITE); 1487 OCFS2_JOURNAL_ACCESS_WRITE);
1461 if (status < 0) { 1488 if (status < 0) {
1462 mlog_errno(status); 1489 mlog_errno(status);
1463 goto bail; 1490 goto bail;
1464 } 1491 }
1465 1492
1466 /* change the dirent to point to the correct inode */ 1493 /* change the dirent to point to the correct inode */
1467 status = ocfs2_update_entry(new_dir, handle, &target_lookup_res, 1494 status = ocfs2_update_entry(new_dir, handle, &target_lookup_res,
1468 old_inode); 1495 old_inode);
1469 if (status < 0) { 1496 if (status < 0) {
1470 mlog_errno(status); 1497 mlog_errno(status);
1471 goto bail; 1498 goto bail;
1472 } 1499 }
1473 new_dir->i_version++; 1500 new_dir->i_version++;
1474 1501
1475 if (S_ISDIR(new_inode->i_mode)) 1502 if (S_ISDIR(new_inode->i_mode))
1476 ocfs2_set_links_count(newfe, 0); 1503 ocfs2_set_links_count(newfe, 0);
1477 else 1504 else
1478 ocfs2_add_links_count(newfe, -1); 1505 ocfs2_add_links_count(newfe, -1);
1479 ocfs2_journal_dirty(handle, newfe_bh); 1506 ocfs2_journal_dirty(handle, newfe_bh);
1480 if (should_add_orphan) { 1507 if (should_add_orphan) {
1481 status = ocfs2_orphan_add(osb, handle, new_inode, 1508 status = ocfs2_orphan_add(osb, handle, new_inode,
1482 newfe_bh, orphan_name, 1509 newfe_bh, orphan_name,
1483 &orphan_insert, orphan_dir); 1510 &orphan_insert, orphan_dir);
1484 if (status < 0) { 1511 if (status < 0) {
1485 mlog_errno(status); 1512 mlog_errno(status);
1486 goto bail; 1513 goto bail;
1487 } 1514 }
1488 } 1515 }
1489 } else { 1516 } else {
1490 /* if the name was not found in new_dir, add it now */ 1517 /* if the name was not found in new_dir, add it now */
1491 status = ocfs2_add_entry(handle, new_dentry, old_inode, 1518 status = ocfs2_add_entry(handle, new_dentry, old_inode,
1492 OCFS2_I(old_inode)->ip_blkno, 1519 OCFS2_I(old_inode)->ip_blkno,
1493 new_dir_bh, &target_insert); 1520 new_dir_bh, &target_insert);
1494 } 1521 }
1495 1522
1496 old_inode->i_ctime = CURRENT_TIME; 1523 old_inode->i_ctime = CURRENT_TIME;
1497 mark_inode_dirty(old_inode); 1524 mark_inode_dirty(old_inode);
1498 1525
1499 status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode), 1526 status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
1500 old_inode_bh, 1527 old_inode_bh,
1501 OCFS2_JOURNAL_ACCESS_WRITE); 1528 OCFS2_JOURNAL_ACCESS_WRITE);
1502 if (status >= 0) { 1529 if (status >= 0) {
1503 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data; 1530 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1504 1531
1505 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec); 1532 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
1506 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec); 1533 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1507 ocfs2_journal_dirty(handle, old_inode_bh); 1534 ocfs2_journal_dirty(handle, old_inode_bh);
1508 } else 1535 } else
1509 mlog_errno(status); 1536 mlog_errno(status);
1510 1537
1511 /* 1538 /*
1512 * Now that the name has been added to new_dir, remove the old name. 1539 * Now that the name has been added to new_dir, remove the old name.
1513 * 1540 *
1514 * We don't keep any directory entry context around until now 1541 * We don't keep any directory entry context around until now
1515 * because the insert might have changed the type of directory 1542 * because the insert might have changed the type of directory
1516 * we're dealing with. 1543 * we're dealing with.
1517 */ 1544 */
1518 status = ocfs2_find_entry(old_dentry->d_name.name, 1545 status = ocfs2_find_entry(old_dentry->d_name.name,
1519 old_dentry->d_name.len, old_dir, 1546 old_dentry->d_name.len, old_dir,
1520 &old_entry_lookup); 1547 &old_entry_lookup);
1521 if (status) 1548 if (status)
1522 goto bail; 1549 goto bail;
1523 1550
1524 status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup); 1551 status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup);
1525 if (status < 0) { 1552 if (status < 0) {
1526 mlog_errno(status); 1553 mlog_errno(status);
1527 goto bail; 1554 goto bail;
1528 } 1555 }
1529 1556
1530 if (new_inode) { 1557 if (new_inode) {
1531 drop_nlink(new_inode); 1558 drop_nlink(new_inode);
1532 new_inode->i_ctime = CURRENT_TIME; 1559 new_inode->i_ctime = CURRENT_TIME;
1533 } 1560 }
1534 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME; 1561 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1535 1562
1536 if (update_dot_dot) { 1563 if (update_dot_dot) {
1537 status = ocfs2_update_entry(old_inode, handle, 1564 status = ocfs2_update_entry(old_inode, handle,
1538 &old_inode_dot_dot_res, new_dir); 1565 &old_inode_dot_dot_res, new_dir);
1539 drop_nlink(old_dir); 1566 drop_nlink(old_dir);
1540 if (new_inode) { 1567 if (new_inode) {
1541 drop_nlink(new_inode); 1568 drop_nlink(new_inode);
1542 } else { 1569 } else {
1543 inc_nlink(new_dir); 1570 inc_nlink(new_dir);
1544 mark_inode_dirty(new_dir); 1571 mark_inode_dirty(new_dir);
1545 } 1572 }
1546 } 1573 }
1547 mark_inode_dirty(old_dir); 1574 mark_inode_dirty(old_dir);
1548 ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh); 1575 ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1549 if (new_inode) { 1576 if (new_inode) {
1550 mark_inode_dirty(new_inode); 1577 mark_inode_dirty(new_inode);
1551 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh); 1578 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1552 } 1579 }
1553 1580
1554 if (old_dir != new_dir) { 1581 if (old_dir != new_dir) {
1555 /* Keep the same times on both directories.*/ 1582 /* Keep the same times on both directories.*/
1556 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime; 1583 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1557 1584
1558 /* 1585 /*
1559 * This will also pick up the i_nlink change from the 1586 * This will also pick up the i_nlink change from the
1560 * block above. 1587 * block above.
1561 */ 1588 */
1562 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh); 1589 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1563 } 1590 }
1564 1591
1565 if (old_dir_nlink != old_dir->i_nlink) { 1592 if (old_dir_nlink != old_dir->i_nlink) {
1566 if (!old_dir_bh) { 1593 if (!old_dir_bh) {
1567 mlog(ML_ERROR, "need to change nlink for old dir " 1594 mlog(ML_ERROR, "need to change nlink for old dir "
1568 "%llu from %d to %d but bh is NULL!\n", 1595 "%llu from %d to %d but bh is NULL!\n",
1569 (unsigned long long)OCFS2_I(old_dir)->ip_blkno, 1596 (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1570 (int)old_dir_nlink, old_dir->i_nlink); 1597 (int)old_dir_nlink, old_dir->i_nlink);
1571 } else { 1598 } else {
1572 struct ocfs2_dinode *fe; 1599 struct ocfs2_dinode *fe;
1573 status = ocfs2_journal_access_di(handle, 1600 status = ocfs2_journal_access_di(handle,
1574 INODE_CACHE(old_dir), 1601 INODE_CACHE(old_dir),
1575 old_dir_bh, 1602 old_dir_bh,
1576 OCFS2_JOURNAL_ACCESS_WRITE); 1603 OCFS2_JOURNAL_ACCESS_WRITE);
1577 fe = (struct ocfs2_dinode *) old_dir_bh->b_data; 1604 fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1578 ocfs2_set_links_count(fe, old_dir->i_nlink); 1605 ocfs2_set_links_count(fe, old_dir->i_nlink);
1579 ocfs2_journal_dirty(handle, old_dir_bh); 1606 ocfs2_journal_dirty(handle, old_dir_bh);
1580 } 1607 }
1581 } 1608 }
1582 ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir); 1609 ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1583 status = 0; 1610 status = 0;
1584 bail: 1611 bail:
1585 if (rename_lock) 1612 if (rename_lock)
1586 ocfs2_rename_unlock(osb); 1613 ocfs2_rename_unlock(osb);
1587 1614
1588 if (handle) 1615 if (handle)
1589 ocfs2_commit_trans(osb, handle); 1616 ocfs2_commit_trans(osb, handle);
1590 1617
1591 if (parents_locked) 1618 if (parents_locked)
1592 ocfs2_double_unlock(old_dir, new_dir); 1619 ocfs2_double_unlock(old_dir, new_dir);
1593 1620
1594 if (old_child_locked) 1621 if (old_child_locked)
1595 ocfs2_inode_unlock(old_inode, 1); 1622 ocfs2_inode_unlock(old_inode, 1);
1596 1623
1597 if (new_child_locked) 1624 if (new_child_locked)
1598 ocfs2_inode_unlock(new_inode, 1); 1625 ocfs2_inode_unlock(new_inode, 1);
1599 1626
1600 if (orphan_dir) { 1627 if (orphan_dir) {
1601 /* This was locked for us in ocfs2_prepare_orphan_dir() */ 1628 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1602 ocfs2_inode_unlock(orphan_dir, 1); 1629 ocfs2_inode_unlock(orphan_dir, 1);
1603 mutex_unlock(&orphan_dir->i_mutex); 1630 mutex_unlock(&orphan_dir->i_mutex);
1604 iput(orphan_dir); 1631 iput(orphan_dir);
1605 } 1632 }
1606 1633
1607 if (new_inode) 1634 if (new_inode)
1608 sync_mapping_buffers(old_inode->i_mapping); 1635 sync_mapping_buffers(old_inode->i_mapping);
1609 1636
1610 if (new_inode) 1637 if (new_inode)
1611 iput(new_inode); 1638 iput(new_inode);
1612 1639
1613 ocfs2_free_dir_lookup_result(&target_lookup_res); 1640 ocfs2_free_dir_lookup_result(&target_lookup_res);
1614 ocfs2_free_dir_lookup_result(&old_entry_lookup); 1641 ocfs2_free_dir_lookup_result(&old_entry_lookup);
1615 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res); 1642 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res);
1616 ocfs2_free_dir_lookup_result(&orphan_insert); 1643 ocfs2_free_dir_lookup_result(&orphan_insert);
1617 ocfs2_free_dir_lookup_result(&target_insert); 1644 ocfs2_free_dir_lookup_result(&target_insert);
1618 1645
1619 brelse(newfe_bh); 1646 brelse(newfe_bh);
1620 brelse(old_inode_bh); 1647 brelse(old_inode_bh);
1621 brelse(old_dir_bh); 1648 brelse(old_dir_bh);
1622 brelse(new_dir_bh); 1649 brelse(new_dir_bh);
1623 1650
1624 if (status) 1651 if (status)
1625 mlog_errno(status); 1652 mlog_errno(status);
1626 1653
1627 return status; 1654 return status;
1628 } 1655 }
1629 1656
1630 /* 1657 /*
1631 * we expect i_size = strlen(symname). Copy symname into the file 1658 * we expect i_size = strlen(symname). Copy symname into the file
1632 * data, including the null terminator. 1659 * data, including the null terminator.
1633 */ 1660 */
1634 static int ocfs2_create_symlink_data(struct ocfs2_super *osb, 1661 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1635 handle_t *handle, 1662 handle_t *handle,
1636 struct inode *inode, 1663 struct inode *inode,
1637 const char *symname) 1664 const char *symname)
1638 { 1665 {
1639 struct buffer_head **bhs = NULL; 1666 struct buffer_head **bhs = NULL;
1640 const char *c; 1667 const char *c;
1641 struct super_block *sb = osb->sb; 1668 struct super_block *sb = osb->sb;
1642 u64 p_blkno, p_blocks; 1669 u64 p_blkno, p_blocks;
1643 int virtual, blocks, status, i, bytes_left; 1670 int virtual, blocks, status, i, bytes_left;
1644 1671
1645 bytes_left = i_size_read(inode) + 1; 1672 bytes_left = i_size_read(inode) + 1;
1646 /* we can't trust i_blocks because we're actually going to 1673 /* we can't trust i_blocks because we're actually going to
1647 * write i_size + 1 bytes. */ 1674 * write i_size + 1 bytes. */
1648 blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits; 1675 blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1649 1676
1650 trace_ocfs2_create_symlink_data((unsigned long long)inode->i_blocks, 1677 trace_ocfs2_create_symlink_data((unsigned long long)inode->i_blocks,
1651 i_size_read(inode), blocks); 1678 i_size_read(inode), blocks);
1652 1679
1653 /* Sanity check -- make sure we're going to fit. */ 1680 /* Sanity check -- make sure we're going to fit. */
1654 if (bytes_left > 1681 if (bytes_left >
1655 ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) { 1682 ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1656 status = -EIO; 1683 status = -EIO;
1657 mlog_errno(status); 1684 mlog_errno(status);
1658 goto bail; 1685 goto bail;
1659 } 1686 }
1660 1687
1661 bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL); 1688 bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1662 if (!bhs) { 1689 if (!bhs) {
1663 status = -ENOMEM; 1690 status = -ENOMEM;
1664 mlog_errno(status); 1691 mlog_errno(status);
1665 goto bail; 1692 goto bail;
1666 } 1693 }
1667 1694
1668 status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks, 1695 status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1669 NULL); 1696 NULL);
1670 if (status < 0) { 1697 if (status < 0) {
1671 mlog_errno(status); 1698 mlog_errno(status);
1672 goto bail; 1699 goto bail;
1673 } 1700 }
1674 1701
1675 /* links can never be larger than one cluster so we know this 1702 /* links can never be larger than one cluster so we know this
1676 * is all going to be contiguous, but do a sanity check 1703 * is all going to be contiguous, but do a sanity check
1677 * anyway. */ 1704 * anyway. */
1678 if ((p_blocks << sb->s_blocksize_bits) < bytes_left) { 1705 if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1679 status = -EIO; 1706 status = -EIO;
1680 mlog_errno(status); 1707 mlog_errno(status);
1681 goto bail; 1708 goto bail;
1682 } 1709 }
1683 1710
1684 virtual = 0; 1711 virtual = 0;
1685 while(bytes_left > 0) { 1712 while(bytes_left > 0) {
1686 c = &symname[virtual * sb->s_blocksize]; 1713 c = &symname[virtual * sb->s_blocksize];
1687 1714
1688 bhs[virtual] = sb_getblk(sb, p_blkno); 1715 bhs[virtual] = sb_getblk(sb, p_blkno);
1689 if (!bhs[virtual]) { 1716 if (!bhs[virtual]) {
1690 status = -ENOMEM; 1717 status = -ENOMEM;
1691 mlog_errno(status); 1718 mlog_errno(status);
1692 goto bail; 1719 goto bail;
1693 } 1720 }
1694 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), 1721 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode),
1695 bhs[virtual]); 1722 bhs[virtual]);
1696 1723
1697 status = ocfs2_journal_access(handle, INODE_CACHE(inode), 1724 status = ocfs2_journal_access(handle, INODE_CACHE(inode),
1698 bhs[virtual], 1725 bhs[virtual],
1699 OCFS2_JOURNAL_ACCESS_CREATE); 1726 OCFS2_JOURNAL_ACCESS_CREATE);
1700 if (status < 0) { 1727 if (status < 0) {
1701 mlog_errno(status); 1728 mlog_errno(status);
1702 goto bail; 1729 goto bail;
1703 } 1730 }
1704 1731
1705 memset(bhs[virtual]->b_data, 0, sb->s_blocksize); 1732 memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1706 1733
1707 memcpy(bhs[virtual]->b_data, c, 1734 memcpy(bhs[virtual]->b_data, c,
1708 (bytes_left > sb->s_blocksize) ? sb->s_blocksize : 1735 (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1709 bytes_left); 1736 bytes_left);
1710 1737
1711 ocfs2_journal_dirty(handle, bhs[virtual]); 1738 ocfs2_journal_dirty(handle, bhs[virtual]);
1712 1739
1713 virtual++; 1740 virtual++;
1714 p_blkno++; 1741 p_blkno++;
1715 bytes_left -= sb->s_blocksize; 1742 bytes_left -= sb->s_blocksize;
1716 } 1743 }
1717 1744
1718 status = 0; 1745 status = 0;
1719 bail: 1746 bail:
1720 1747
1721 if (bhs) { 1748 if (bhs) {
1722 for(i = 0; i < blocks; i++) 1749 for(i = 0; i < blocks; i++)
1723 brelse(bhs[i]); 1750 brelse(bhs[i]);
1724 kfree(bhs); 1751 kfree(bhs);
1725 } 1752 }
1726 1753
1727 if (status) 1754 if (status)
1728 mlog_errno(status); 1755 mlog_errno(status);
1729 return status; 1756 return status;
1730 } 1757 }
1731 1758
1732 static int ocfs2_symlink(struct inode *dir, 1759 static int ocfs2_symlink(struct inode *dir,
1733 struct dentry *dentry, 1760 struct dentry *dentry,
1734 const char *symname) 1761 const char *symname)
1735 { 1762 {
1736 int status, l, credits; 1763 int status, l, credits;
1737 u64 newsize; 1764 u64 newsize;
1738 struct ocfs2_super *osb = NULL; 1765 struct ocfs2_super *osb = NULL;
1739 struct inode *inode = NULL; 1766 struct inode *inode = NULL;
1740 struct super_block *sb; 1767 struct super_block *sb;
1741 struct buffer_head *new_fe_bh = NULL; 1768 struct buffer_head *new_fe_bh = NULL;
1742 struct buffer_head *parent_fe_bh = NULL; 1769 struct buffer_head *parent_fe_bh = NULL;
1743 struct ocfs2_dinode *fe = NULL; 1770 struct ocfs2_dinode *fe = NULL;
1744 struct ocfs2_dinode *dirfe; 1771 struct ocfs2_dinode *dirfe;
1745 handle_t *handle = NULL; 1772 handle_t *handle = NULL;
1746 struct ocfs2_alloc_context *inode_ac = NULL; 1773 struct ocfs2_alloc_context *inode_ac = NULL;
1747 struct ocfs2_alloc_context *data_ac = NULL; 1774 struct ocfs2_alloc_context *data_ac = NULL;
1748 struct ocfs2_alloc_context *xattr_ac = NULL; 1775 struct ocfs2_alloc_context *xattr_ac = NULL;
1749 int want_clusters = 0; 1776 int want_clusters = 0;
1750 int xattr_credits = 0; 1777 int xattr_credits = 0;
1751 struct ocfs2_security_xattr_info si = { 1778 struct ocfs2_security_xattr_info si = {
1752 .enable = 1, 1779 .enable = 1,
1753 }; 1780 };
1754 int did_quota = 0, did_quota_inode = 0; 1781 int did_quota = 0, did_quota_inode = 0;
1755 struct ocfs2_dir_lookup_result lookup = { NULL, }; 1782 struct ocfs2_dir_lookup_result lookup = { NULL, };
1756 sigset_t oldset; 1783 sigset_t oldset;
1757 int did_block_signals = 0; 1784 int did_block_signals = 0;
1758 struct ocfs2_dentry_lock *dl = NULL; 1785 struct ocfs2_dentry_lock *dl = NULL;
1759 1786
1760 trace_ocfs2_symlink_begin(dir, dentry, symname, 1787 trace_ocfs2_symlink_begin(dir, dentry, symname,
1761 dentry->d_name.len, dentry->d_name.name); 1788 dentry->d_name.len, dentry->d_name.name);
1762 1789
1763 dquot_initialize(dir); 1790 dquot_initialize(dir);
1764 1791
1765 sb = dir->i_sb; 1792 sb = dir->i_sb;
1766 osb = OCFS2_SB(sb); 1793 osb = OCFS2_SB(sb);
1767 1794
1768 l = strlen(symname) + 1; 1795 l = strlen(symname) + 1;
1769 1796
1770 credits = ocfs2_calc_symlink_credits(sb); 1797 credits = ocfs2_calc_symlink_credits(sb);
1771 1798
1772 /* lock the parent directory */ 1799 /* lock the parent directory */
1773 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1); 1800 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1774 if (status < 0) { 1801 if (status < 0) {
1775 if (status != -ENOENT) 1802 if (status != -ENOENT)
1776 mlog_errno(status); 1803 mlog_errno(status);
1777 return status; 1804 return status;
1778 } 1805 }
1779 1806
1780 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data; 1807 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1781 if (!ocfs2_read_links_count(dirfe)) { 1808 if (!ocfs2_read_links_count(dirfe)) {
1782 /* can't make a file in a deleted directory. */ 1809 /* can't make a file in a deleted directory. */
1783 status = -ENOENT; 1810 status = -ENOENT;
1784 goto bail; 1811 goto bail;
1785 } 1812 }
1786 1813
1787 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 1814 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1788 dentry->d_name.len); 1815 dentry->d_name.len);
1789 if (status) 1816 if (status)
1790 goto bail; 1817 goto bail;
1791 1818
1792 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh, 1819 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1793 dentry->d_name.name, 1820 dentry->d_name.name,
1794 dentry->d_name.len, &lookup); 1821 dentry->d_name.len, &lookup);
1795 if (status < 0) { 1822 if (status < 0) {
1796 mlog_errno(status); 1823 mlog_errno(status);
1797 goto bail; 1824 goto bail;
1798 } 1825 }
1799 1826
1800 status = ocfs2_reserve_new_inode(osb, &inode_ac); 1827 status = ocfs2_reserve_new_inode(osb, &inode_ac);
1801 if (status < 0) { 1828 if (status < 0) {
1802 if (status != -ENOSPC) 1829 if (status != -ENOSPC)
1803 mlog_errno(status); 1830 mlog_errno(status);
1804 goto bail; 1831 goto bail;
1805 } 1832 }
1806 1833
1807 inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO); 1834 inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
1808 if (!inode) { 1835 if (!inode) {
1809 status = -ENOMEM; 1836 status = -ENOMEM;
1810 mlog_errno(status); 1837 mlog_errno(status);
1811 goto bail; 1838 goto bail;
1812 } 1839 }
1813 1840
1814 /* get security xattr */ 1841 /* get security xattr */
1815 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si); 1842 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
1816 if (status) { 1843 if (status) {
1817 if (status == -EOPNOTSUPP) 1844 if (status == -EOPNOTSUPP)
1818 si.enable = 0; 1845 si.enable = 0;
1819 else { 1846 else {
1820 mlog_errno(status); 1847 mlog_errno(status);
1821 goto bail; 1848 goto bail;
1822 } 1849 }
1823 } 1850 }
1824 1851
1825 /* calculate meta data/clusters for setting security xattr */ 1852 /* calculate meta data/clusters for setting security xattr */
1826 if (si.enable) { 1853 if (si.enable) {
1827 status = ocfs2_calc_security_init(dir, &si, &want_clusters, 1854 status = ocfs2_calc_security_init(dir, &si, &want_clusters,
1828 &xattr_credits, &xattr_ac); 1855 &xattr_credits, &xattr_ac);
1829 if (status < 0) { 1856 if (status < 0) {
1830 mlog_errno(status); 1857 mlog_errno(status);
1831 goto bail; 1858 goto bail;
1832 } 1859 }
1833 } 1860 }
1834 1861
1835 /* don't reserve bitmap space for fast symlinks. */ 1862 /* don't reserve bitmap space for fast symlinks. */
1836 if (l > ocfs2_fast_symlink_chars(sb)) 1863 if (l > ocfs2_fast_symlink_chars(sb))
1837 want_clusters += 1; 1864 want_clusters += 1;
1838 1865
1839 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac); 1866 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
1840 if (status < 0) { 1867 if (status < 0) {
1841 if (status != -ENOSPC) 1868 if (status != -ENOSPC)
1842 mlog_errno(status); 1869 mlog_errno(status);
1843 goto bail; 1870 goto bail;
1844 } 1871 }
1845 1872
1846 handle = ocfs2_start_trans(osb, credits + xattr_credits); 1873 handle = ocfs2_start_trans(osb, credits + xattr_credits);
1847 if (IS_ERR(handle)) { 1874 if (IS_ERR(handle)) {
1848 status = PTR_ERR(handle); 1875 status = PTR_ERR(handle);
1849 handle = NULL; 1876 handle = NULL;
1850 mlog_errno(status); 1877 mlog_errno(status);
1851 goto bail; 1878 goto bail;
1852 } 1879 }
1853 1880
1854 /* Starting to change things, restart is no longer possible. */ 1881 /* Starting to change things, restart is no longer possible. */
1855 ocfs2_block_signals(&oldset); 1882 ocfs2_block_signals(&oldset);
1856 did_block_signals = 1; 1883 did_block_signals = 1;
1857 1884
1858 status = dquot_alloc_inode(inode); 1885 status = dquot_alloc_inode(inode);
1859 if (status) 1886 if (status)
1860 goto bail; 1887 goto bail;
1861 did_quota_inode = 1; 1888 did_quota_inode = 1;
1862 1889
1863 trace_ocfs2_symlink_create(dir, dentry, dentry->d_name.len, 1890 trace_ocfs2_symlink_create(dir, dentry, dentry->d_name.len,
1864 dentry->d_name.name, 1891 dentry->d_name.name,
1865 (unsigned long long)OCFS2_I(dir)->ip_blkno, 1892 (unsigned long long)OCFS2_I(dir)->ip_blkno,
1866 inode->i_mode); 1893 inode->i_mode);
1867 1894
1868 status = ocfs2_mknod_locked(osb, dir, inode, 1895 status = ocfs2_mknod_locked(osb, dir, inode,
1869 0, &new_fe_bh, parent_fe_bh, handle, 1896 0, &new_fe_bh, parent_fe_bh, handle,
1870 inode_ac); 1897 inode_ac);
1871 if (status < 0) { 1898 if (status < 0) {
1872 mlog_errno(status); 1899 mlog_errno(status);
1873 goto bail; 1900 goto bail;
1874 } 1901 }
1875 1902
1876 fe = (struct ocfs2_dinode *) new_fe_bh->b_data; 1903 fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1877 inode->i_rdev = 0; 1904 inode->i_rdev = 0;
1878 newsize = l - 1; 1905 newsize = l - 1;
1879 inode->i_op = &ocfs2_symlink_inode_operations; 1906 inode->i_op = &ocfs2_symlink_inode_operations;
1880 if (l > ocfs2_fast_symlink_chars(sb)) { 1907 if (l > ocfs2_fast_symlink_chars(sb)) {
1881 u32 offset = 0; 1908 u32 offset = 0;
1882 1909
1883 status = dquot_alloc_space_nodirty(inode, 1910 status = dquot_alloc_space_nodirty(inode,
1884 ocfs2_clusters_to_bytes(osb->sb, 1)); 1911 ocfs2_clusters_to_bytes(osb->sb, 1));
1885 if (status) 1912 if (status)
1886 goto bail; 1913 goto bail;
1887 did_quota = 1; 1914 did_quota = 1;
1888 inode->i_mapping->a_ops = &ocfs2_aops; 1915 inode->i_mapping->a_ops = &ocfs2_aops;
1889 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0, 1916 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
1890 new_fe_bh, 1917 new_fe_bh,
1891 handle, data_ac, NULL, 1918 handle, data_ac, NULL,
1892 NULL); 1919 NULL);
1893 if (status < 0) { 1920 if (status < 0) {
1894 if (status != -ENOSPC && status != -EINTR) { 1921 if (status != -ENOSPC && status != -EINTR) {
1895 mlog(ML_ERROR, 1922 mlog(ML_ERROR,
1896 "Failed to extend file to %llu\n", 1923 "Failed to extend file to %llu\n",
1897 (unsigned long long)newsize); 1924 (unsigned long long)newsize);
1898 mlog_errno(status); 1925 mlog_errno(status);
1899 status = -ENOSPC; 1926 status = -ENOSPC;
1900 } 1927 }
1901 goto bail; 1928 goto bail;
1902 } 1929 }
1903 i_size_write(inode, newsize); 1930 i_size_write(inode, newsize);
1904 inode->i_blocks = ocfs2_inode_sector_count(inode); 1931 inode->i_blocks = ocfs2_inode_sector_count(inode);
1905 } else { 1932 } else {
1906 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops; 1933 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops;
1907 memcpy((char *) fe->id2.i_symlink, symname, l); 1934 memcpy((char *) fe->id2.i_symlink, symname, l);
1908 i_size_write(inode, newsize); 1935 i_size_write(inode, newsize);
1909 inode->i_blocks = 0; 1936 inode->i_blocks = 0;
1910 } 1937 }
1911 1938
1912 status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh); 1939 status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1913 if (status < 0) { 1940 if (status < 0) {
1914 mlog_errno(status); 1941 mlog_errno(status);
1915 goto bail; 1942 goto bail;
1916 } 1943 }
1917 1944
1918 if (!ocfs2_inode_is_fast_symlink(inode)) { 1945 if (!ocfs2_inode_is_fast_symlink(inode)) {
1919 status = ocfs2_create_symlink_data(osb, handle, inode, 1946 status = ocfs2_create_symlink_data(osb, handle, inode,
1920 symname); 1947 symname);
1921 if (status < 0) { 1948 if (status < 0) {
1922 mlog_errno(status); 1949 mlog_errno(status);
1923 goto bail; 1950 goto bail;
1924 } 1951 }
1925 } 1952 }
1926 1953
1927 if (si.enable) { 1954 if (si.enable) {
1928 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si, 1955 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
1929 xattr_ac, data_ac); 1956 xattr_ac, data_ac);
1930 if (status < 0) { 1957 if (status < 0) {
1931 mlog_errno(status); 1958 mlog_errno(status);
1932 goto bail; 1959 goto bail;
1933 } 1960 }
1934 } 1961 }
1935 1962
1936 /* 1963 /*
1937 * Do this before adding the entry to the directory. We add 1964 * Do this before adding the entry to the directory. We add
1938 * also set d_op after success so that ->d_iput() will cleanup 1965 * also set d_op after success so that ->d_iput() will cleanup
1939 * the dentry lock even if ocfs2_add_entry() fails below. 1966 * the dentry lock even if ocfs2_add_entry() fails below.
1940 */ 1967 */
1941 status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno); 1968 status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
1942 if (status) { 1969 if (status) {
1943 mlog_errno(status); 1970 mlog_errno(status);
1944 goto bail; 1971 goto bail;
1945 } 1972 }
1946 1973
1947 dl = dentry->d_fsdata; 1974 dl = dentry->d_fsdata;
1948 1975
1949 status = ocfs2_add_entry(handle, dentry, inode, 1976 status = ocfs2_add_entry(handle, dentry, inode,
1950 le64_to_cpu(fe->i_blkno), parent_fe_bh, 1977 le64_to_cpu(fe->i_blkno), parent_fe_bh,
1951 &lookup); 1978 &lookup);
1952 if (status < 0) { 1979 if (status < 0) {
1953 mlog_errno(status); 1980 mlog_errno(status);
1954 goto bail; 1981 goto bail;
1955 } 1982 }
1956 1983
1957 insert_inode_hash(inode); 1984 insert_inode_hash(inode);
1958 d_instantiate(dentry, inode); 1985 d_instantiate(dentry, inode);
1959 bail: 1986 bail:
1960 if (status < 0 && did_quota) 1987 if (status < 0 && did_quota)
1961 dquot_free_space_nodirty(inode, 1988 dquot_free_space_nodirty(inode,
1962 ocfs2_clusters_to_bytes(osb->sb, 1)); 1989 ocfs2_clusters_to_bytes(osb->sb, 1));
1963 if (status < 0 && did_quota_inode) 1990 if (status < 0 && did_quota_inode)
1964 dquot_free_inode(inode); 1991 dquot_free_inode(inode);
1965 if (handle) 1992 if (handle)
1966 ocfs2_commit_trans(osb, handle); 1993 ocfs2_commit_trans(osb, handle);
1967 1994
1968 ocfs2_inode_unlock(dir, 1); 1995 ocfs2_inode_unlock(dir, 1);
1969 if (did_block_signals) 1996 if (did_block_signals)
1970 ocfs2_unblock_signals(&oldset); 1997 ocfs2_unblock_signals(&oldset);
1971 1998
1972 brelse(new_fe_bh); 1999 brelse(new_fe_bh);
1973 brelse(parent_fe_bh); 2000 brelse(parent_fe_bh);
1974 kfree(si.value); 2001 kfree(si.value);
1975 ocfs2_free_dir_lookup_result(&lookup); 2002 ocfs2_free_dir_lookup_result(&lookup);
1976 if (inode_ac) 2003 if (inode_ac)
1977 ocfs2_free_alloc_context(inode_ac); 2004 ocfs2_free_alloc_context(inode_ac);
1978 if (data_ac) 2005 if (data_ac)
1979 ocfs2_free_alloc_context(data_ac); 2006 ocfs2_free_alloc_context(data_ac);
1980 if (xattr_ac) 2007 if (xattr_ac)
1981 ocfs2_free_alloc_context(xattr_ac); 2008 ocfs2_free_alloc_context(xattr_ac);
1982 if ((status < 0) && inode) { 2009 if ((status < 0) && inode) {
1983 if (dl) 2010 if (dl)
1984 ocfs2_cleanup_add_entry_failure(osb, dentry, inode); 2011 ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
1985 2012
1986 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR; 2013 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
1987 clear_nlink(inode); 2014 clear_nlink(inode);
1988 iput(inode); 2015 iput(inode);
1989 } 2016 }
1990 2017
1991 if (status) 2018 if (status)
1992 mlog_errno(status); 2019 mlog_errno(status);
1993 2020
1994 return status; 2021 return status;
1995 } 2022 }
1996 2023
1997 static int ocfs2_blkno_stringify(u64 blkno, char *name) 2024 static int ocfs2_blkno_stringify(u64 blkno, char *name)
1998 { 2025 {
1999 int status, namelen; 2026 int status, namelen;
2000 2027
2001 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx", 2028 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
2002 (long long)blkno); 2029 (long long)blkno);
2003 if (namelen <= 0) { 2030 if (namelen <= 0) {
2004 if (namelen) 2031 if (namelen)
2005 status = namelen; 2032 status = namelen;
2006 else 2033 else
2007 status = -EINVAL; 2034 status = -EINVAL;
2008 mlog_errno(status); 2035 mlog_errno(status);
2009 goto bail; 2036 goto bail;
2010 } 2037 }
2011 if (namelen != OCFS2_ORPHAN_NAMELEN) { 2038 if (namelen != OCFS2_ORPHAN_NAMELEN) {
2012 status = -EINVAL; 2039 status = -EINVAL;
2013 mlog_errno(status); 2040 mlog_errno(status);
2014 goto bail; 2041 goto bail;
2015 } 2042 }
2016 2043
2017 trace_ocfs2_blkno_stringify(blkno, name, namelen); 2044 trace_ocfs2_blkno_stringify(blkno, name, namelen);
2018 2045
2019 status = 0; 2046 status = 0;
2020 bail: 2047 bail:
2021 if (status < 0) 2048 if (status < 0)
2022 mlog_errno(status); 2049 mlog_errno(status);
2023 return status; 2050 return status;
2024 } 2051 }
2025 2052
2026 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb, 2053 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb,
2027 struct inode **ret_orphan_dir, 2054 struct inode **ret_orphan_dir,
2028 struct buffer_head **ret_orphan_dir_bh) 2055 struct buffer_head **ret_orphan_dir_bh)
2029 { 2056 {
2030 struct inode *orphan_dir_inode; 2057 struct inode *orphan_dir_inode;
2031 struct buffer_head *orphan_dir_bh = NULL; 2058 struct buffer_head *orphan_dir_bh = NULL;
2032 int ret = 0; 2059 int ret = 0;
2033 2060
2034 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 2061 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2035 ORPHAN_DIR_SYSTEM_INODE, 2062 ORPHAN_DIR_SYSTEM_INODE,
2036 osb->slot_num); 2063 osb->slot_num);
2037 if (!orphan_dir_inode) { 2064 if (!orphan_dir_inode) {
2038 ret = -ENOENT; 2065 ret = -ENOENT;
2039 mlog_errno(ret); 2066 mlog_errno(ret);
2040 return ret; 2067 return ret;
2041 } 2068 }
2042 2069
2043 mutex_lock(&orphan_dir_inode->i_mutex); 2070 mutex_lock(&orphan_dir_inode->i_mutex);
2044 2071
2045 ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1); 2072 ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2046 if (ret < 0) { 2073 if (ret < 0) {
2047 mutex_unlock(&orphan_dir_inode->i_mutex); 2074 mutex_unlock(&orphan_dir_inode->i_mutex);
2048 iput(orphan_dir_inode); 2075 iput(orphan_dir_inode);
2049 2076
2050 mlog_errno(ret); 2077 mlog_errno(ret);
2051 return ret; 2078 return ret;
2052 } 2079 }
2053 2080
2054 *ret_orphan_dir = orphan_dir_inode; 2081 *ret_orphan_dir = orphan_dir_inode;
2055 *ret_orphan_dir_bh = orphan_dir_bh; 2082 *ret_orphan_dir_bh = orphan_dir_bh;
2056 2083
2057 return 0; 2084 return 0;
2058 } 2085 }
2059 2086
2060 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode, 2087 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode,
2061 struct buffer_head *orphan_dir_bh, 2088 struct buffer_head *orphan_dir_bh,
2062 u64 blkno, 2089 u64 blkno,
2063 char *name, 2090 char *name,
2064 struct ocfs2_dir_lookup_result *lookup) 2091 struct ocfs2_dir_lookup_result *lookup)
2065 { 2092 {
2066 int ret; 2093 int ret;
2067 struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb); 2094 struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb);
2068 2095
2069 ret = ocfs2_blkno_stringify(blkno, name); 2096 ret = ocfs2_blkno_stringify(blkno, name);
2070 if (ret < 0) { 2097 if (ret < 0) {
2071 mlog_errno(ret); 2098 mlog_errno(ret);
2072 return ret; 2099 return ret;
2073 } 2100 }
2074 2101
2075 ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode, 2102 ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
2076 orphan_dir_bh, name, 2103 orphan_dir_bh, name,
2077 OCFS2_ORPHAN_NAMELEN, lookup); 2104 OCFS2_ORPHAN_NAMELEN, lookup);
2078 if (ret < 0) { 2105 if (ret < 0) {
2079 mlog_errno(ret); 2106 mlog_errno(ret);
2080 return ret; 2107 return ret;
2081 } 2108 }
2082 2109
2083 return 0; 2110 return 0;
2084 } 2111 }
2085 2112
2086 /** 2113 /**
2087 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for 2114 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2088 * insertion of an orphan. 2115 * insertion of an orphan.
2089 * @osb: ocfs2 file system 2116 * @osb: ocfs2 file system
2090 * @ret_orphan_dir: Orphan dir inode - returned locked! 2117 * @ret_orphan_dir: Orphan dir inode - returned locked!
2091 * @blkno: Actual block number of the inode to be inserted into orphan dir. 2118 * @blkno: Actual block number of the inode to be inserted into orphan dir.
2092 * @lookup: dir lookup result, to be passed back into functions like 2119 * @lookup: dir lookup result, to be passed back into functions like
2093 * ocfs2_orphan_add 2120 * ocfs2_orphan_add
2094 * 2121 *
2095 * Returns zero on success and the ret_orphan_dir, name and lookup 2122 * Returns zero on success and the ret_orphan_dir, name and lookup
2096 * fields will be populated. 2123 * fields will be populated.
2097 * 2124 *
2098 * Returns non-zero on failure. 2125 * Returns non-zero on failure.
2099 */ 2126 */
2100 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb, 2127 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
2101 struct inode **ret_orphan_dir, 2128 struct inode **ret_orphan_dir,
2102 u64 blkno, 2129 u64 blkno,
2103 char *name, 2130 char *name,
2104 struct ocfs2_dir_lookup_result *lookup) 2131 struct ocfs2_dir_lookup_result *lookup)
2105 { 2132 {
2106 struct inode *orphan_dir_inode = NULL; 2133 struct inode *orphan_dir_inode = NULL;
2107 struct buffer_head *orphan_dir_bh = NULL; 2134 struct buffer_head *orphan_dir_bh = NULL;
2108 int ret = 0; 2135 int ret = 0;
2109 2136
2110 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode, 2137 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode,
2111 &orphan_dir_bh); 2138 &orphan_dir_bh);
2112 if (ret < 0) { 2139 if (ret < 0) {
2113 mlog_errno(ret); 2140 mlog_errno(ret);
2114 return ret; 2141 return ret;
2115 } 2142 }
2116 2143
2117 ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh, 2144 ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh,
2118 blkno, name, lookup); 2145 blkno, name, lookup);
2119 if (ret < 0) { 2146 if (ret < 0) {
2120 mlog_errno(ret); 2147 mlog_errno(ret);
2121 goto out; 2148 goto out;
2122 } 2149 }
2123 2150
2124 *ret_orphan_dir = orphan_dir_inode; 2151 *ret_orphan_dir = orphan_dir_inode;
2125 2152
2126 out: 2153 out:
2127 brelse(orphan_dir_bh); 2154 brelse(orphan_dir_bh);
2128 2155
2129 if (ret) { 2156 if (ret) {
2130 ocfs2_inode_unlock(orphan_dir_inode, 1); 2157 ocfs2_inode_unlock(orphan_dir_inode, 1);
2131 mutex_unlock(&orphan_dir_inode->i_mutex); 2158 mutex_unlock(&orphan_dir_inode->i_mutex);
2132 iput(orphan_dir_inode); 2159 iput(orphan_dir_inode);
2133 } 2160 }
2134 2161
2135 if (ret) 2162 if (ret)
2136 mlog_errno(ret); 2163 mlog_errno(ret);
2137 return ret; 2164 return ret;
2138 } 2165 }
2139 2166
2140 static int ocfs2_orphan_add(struct ocfs2_super *osb, 2167 static int ocfs2_orphan_add(struct ocfs2_super *osb,
2141 handle_t *handle, 2168 handle_t *handle,
2142 struct inode *inode, 2169 struct inode *inode,
2143 struct buffer_head *fe_bh, 2170 struct buffer_head *fe_bh,
2144 char *name, 2171 char *name,
2145 struct ocfs2_dir_lookup_result *lookup, 2172 struct ocfs2_dir_lookup_result *lookup,
2146 struct inode *orphan_dir_inode) 2173 struct inode *orphan_dir_inode)
2147 { 2174 {
2148 struct buffer_head *orphan_dir_bh = NULL; 2175 struct buffer_head *orphan_dir_bh = NULL;
2149 int status = 0; 2176 int status = 0;
2150 struct ocfs2_dinode *orphan_fe; 2177 struct ocfs2_dinode *orphan_fe;
2151 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data; 2178 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
2152 2179
2153 trace_ocfs2_orphan_add_begin( 2180 trace_ocfs2_orphan_add_begin(
2154 (unsigned long long)OCFS2_I(inode)->ip_blkno); 2181 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2155 2182
2156 status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh); 2183 status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh);
2157 if (status < 0) { 2184 if (status < 0) {
2158 mlog_errno(status); 2185 mlog_errno(status);
2159 goto leave; 2186 goto leave;
2160 } 2187 }
2161 2188
2162 status = ocfs2_journal_access_di(handle, 2189 status = ocfs2_journal_access_di(handle,
2163 INODE_CACHE(orphan_dir_inode), 2190 INODE_CACHE(orphan_dir_inode),
2164 orphan_dir_bh, 2191 orphan_dir_bh,
2165 OCFS2_JOURNAL_ACCESS_WRITE); 2192 OCFS2_JOURNAL_ACCESS_WRITE);
2166 if (status < 0) { 2193 if (status < 0) {
2167 mlog_errno(status); 2194 mlog_errno(status);
2168 goto leave; 2195 goto leave;
2169 } 2196 }
2170 2197
2171 /* 2198 /*
2172 * We're going to journal the change of i_flags and i_orphaned_slot. 2199 * We're going to journal the change of i_flags and i_orphaned_slot.
2173 * It's safe anyway, though some callers may duplicate the journaling. 2200 * It's safe anyway, though some callers may duplicate the journaling.
2174 * Journaling within the func just make the logic look more 2201 * Journaling within the func just make the logic look more
2175 * straightforward. 2202 * straightforward.
2176 */ 2203 */
2177 status = ocfs2_journal_access_di(handle, 2204 status = ocfs2_journal_access_di(handle,
2178 INODE_CACHE(inode), 2205 INODE_CACHE(inode),
2179 fe_bh, 2206 fe_bh,
2180 OCFS2_JOURNAL_ACCESS_WRITE); 2207 OCFS2_JOURNAL_ACCESS_WRITE);
2181 if (status < 0) { 2208 if (status < 0) {
2182 mlog_errno(status); 2209 mlog_errno(status);
2183 goto leave; 2210 goto leave;
2184 } 2211 }
2185 2212
2186 /* we're a cluster, and nlink can change on disk from 2213 /* we're a cluster, and nlink can change on disk from
2187 * underneath us... */ 2214 * underneath us... */
2188 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data; 2215 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2189 if (S_ISDIR(inode->i_mode)) 2216 if (S_ISDIR(inode->i_mode))
2190 ocfs2_add_links_count(orphan_fe, 1); 2217 ocfs2_add_links_count(orphan_fe, 1);
2191 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe)); 2218 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2192 ocfs2_journal_dirty(handle, orphan_dir_bh); 2219 ocfs2_journal_dirty(handle, orphan_dir_bh);
2193 2220
2194 status = __ocfs2_add_entry(handle, orphan_dir_inode, name, 2221 status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
2195 OCFS2_ORPHAN_NAMELEN, inode, 2222 OCFS2_ORPHAN_NAMELEN, inode,
2196 OCFS2_I(inode)->ip_blkno, 2223 OCFS2_I(inode)->ip_blkno,
2197 orphan_dir_bh, lookup); 2224 orphan_dir_bh, lookup);
2198 if (status < 0) { 2225 if (status < 0) {
2199 mlog_errno(status); 2226 mlog_errno(status);
2200 goto rollback; 2227 goto rollback;
2201 } 2228 }
2202 2229
2203 fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL); 2230 fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL);
2204 OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR; 2231 OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
2205 2232
2206 /* Record which orphan dir our inode now resides 2233 /* Record which orphan dir our inode now resides
2207 * in. delete_inode will use this to determine which orphan 2234 * in. delete_inode will use this to determine which orphan
2208 * dir to lock. */ 2235 * dir to lock. */
2209 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num); 2236 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
2210 2237
2211 ocfs2_journal_dirty(handle, fe_bh); 2238 ocfs2_journal_dirty(handle, fe_bh);
2212 2239
2213 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno, 2240 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
2214 osb->slot_num); 2241 osb->slot_num);
2215 2242
2216 rollback: 2243 rollback:
2217 if (status < 0) { 2244 if (status < 0) {
2218 if (S_ISDIR(inode->i_mode)) 2245 if (S_ISDIR(inode->i_mode))
2219 ocfs2_add_links_count(orphan_fe, -1); 2246 ocfs2_add_links_count(orphan_fe, -1);
2220 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe)); 2247 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2221 } 2248 }
2222 2249
2223 leave: 2250 leave:
2224 brelse(orphan_dir_bh); 2251 brelse(orphan_dir_bh);
2225 2252
2226 return status; 2253 return status;
2227 } 2254 }
2228 2255
2229 /* unlike orphan_add, we expect the orphan dir to already be locked here. */ 2256 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2230 int ocfs2_orphan_del(struct ocfs2_super *osb, 2257 int ocfs2_orphan_del(struct ocfs2_super *osb,
2231 handle_t *handle, 2258 handle_t *handle,
2232 struct inode *orphan_dir_inode, 2259 struct inode *orphan_dir_inode,
2233 struct inode *inode, 2260 struct inode *inode,
2234 struct buffer_head *orphan_dir_bh) 2261 struct buffer_head *orphan_dir_bh)
2235 { 2262 {
2236 char name[OCFS2_ORPHAN_NAMELEN + 1]; 2263 char name[OCFS2_ORPHAN_NAMELEN + 1];
2237 struct ocfs2_dinode *orphan_fe; 2264 struct ocfs2_dinode *orphan_fe;
2238 int status = 0; 2265 int status = 0;
2239 struct ocfs2_dir_lookup_result lookup = { NULL, }; 2266 struct ocfs2_dir_lookup_result lookup = { NULL, };
2240 2267
2241 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name); 2268 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2242 if (status < 0) { 2269 if (status < 0) {
2243 mlog_errno(status); 2270 mlog_errno(status);
2244 goto leave; 2271 goto leave;
2245 } 2272 }
2246 2273
2247 trace_ocfs2_orphan_del( 2274 trace_ocfs2_orphan_del(
2248 (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno, 2275 (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
2249 name, OCFS2_ORPHAN_NAMELEN); 2276 name, OCFS2_ORPHAN_NAMELEN);
2250 2277
2251 /* find it's spot in the orphan directory */ 2278 /* find it's spot in the orphan directory */
2252 status = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN, orphan_dir_inode, 2279 status = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN, orphan_dir_inode,
2253 &lookup); 2280 &lookup);
2254 if (status) { 2281 if (status) {
2255 mlog_errno(status); 2282 mlog_errno(status);
2256 goto leave; 2283 goto leave;
2257 } 2284 }
2258 2285
2259 /* remove it from the orphan directory */ 2286 /* remove it from the orphan directory */
2260 status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup); 2287 status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup);
2261 if (status < 0) { 2288 if (status < 0) {
2262 mlog_errno(status); 2289 mlog_errno(status);
2263 goto leave; 2290 goto leave;
2264 } 2291 }
2265 2292
2266 status = ocfs2_journal_access_di(handle, 2293 status = ocfs2_journal_access_di(handle,
2267 INODE_CACHE(orphan_dir_inode), 2294 INODE_CACHE(orphan_dir_inode),
2268 orphan_dir_bh, 2295 orphan_dir_bh,
2269 OCFS2_JOURNAL_ACCESS_WRITE); 2296 OCFS2_JOURNAL_ACCESS_WRITE);
2270 if (status < 0) { 2297 if (status < 0) {
2271 mlog_errno(status); 2298 mlog_errno(status);
2272 goto leave; 2299 goto leave;
2273 } 2300 }
2274 2301
2275 /* do the i_nlink dance! :) */ 2302 /* do the i_nlink dance! :) */
2276 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data; 2303 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2277 if (S_ISDIR(inode->i_mode)) 2304 if (S_ISDIR(inode->i_mode))
2278 ocfs2_add_links_count(orphan_fe, -1); 2305 ocfs2_add_links_count(orphan_fe, -1);
2279 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe)); 2306 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2280 ocfs2_journal_dirty(handle, orphan_dir_bh); 2307 ocfs2_journal_dirty(handle, orphan_dir_bh);
2281 2308
2282 leave: 2309 leave:
2283 ocfs2_free_dir_lookup_result(&lookup); 2310 ocfs2_free_dir_lookup_result(&lookup);
2284 2311
2285 if (status) 2312 if (status)
2286 mlog_errno(status); 2313 mlog_errno(status);
2287 return status; 2314 return status;
2288 } 2315 }
2289 2316
2290 /** 2317 /**
2291 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly 2318 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2292 * allocated file. This is different from the typical 'add to orphan dir' 2319 * allocated file. This is different from the typical 'add to orphan dir'
2293 * operation in that the inode does not yet exist. This is a problem because 2320 * operation in that the inode does not yet exist. This is a problem because
2294 * the orphan dir stringifies the inode block number to come up with it's 2321 * the orphan dir stringifies the inode block number to come up with it's
2295 * dirent. Obviously if the inode does not yet exist we have a chicken and egg 2322 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2296 * problem. This function works around it by calling deeper into the orphan 2323 * problem. This function works around it by calling deeper into the orphan
2297 * and suballoc code than other callers. Use this only by necessity. 2324 * and suballoc code than other callers. Use this only by necessity.
2298 * @dir: The directory which this inode will ultimately wind up under - not the 2325 * @dir: The directory which this inode will ultimately wind up under - not the
2299 * orphan dir! 2326 * orphan dir!
2300 * @dir_bh: buffer_head the @dir inode block 2327 * @dir_bh: buffer_head the @dir inode block
2301 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled 2328 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2302 * with the string to be used for orphan dirent. Pass back to the orphan dir 2329 * with the string to be used for orphan dirent. Pass back to the orphan dir
2303 * code. 2330 * code.
2304 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan 2331 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2305 * dir code. 2332 * dir code.
2306 * @ret_di_blkno: block number where the new inode will be allocated. 2333 * @ret_di_blkno: block number where the new inode will be allocated.
2307 * @orphan_insert: Dir insert context to be passed back into orphan dir code. 2334 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2308 * @ret_inode_ac: Inode alloc context to be passed back to the allocator. 2335 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2309 * 2336 *
2310 * Returns zero on success and the ret_orphan_dir, name and lookup 2337 * Returns zero on success and the ret_orphan_dir, name and lookup
2311 * fields will be populated. 2338 * fields will be populated.
2312 * 2339 *
2313 * Returns non-zero on failure. 2340 * Returns non-zero on failure.
2314 */ 2341 */
2315 static int ocfs2_prep_new_orphaned_file(struct inode *dir, 2342 static int ocfs2_prep_new_orphaned_file(struct inode *dir,
2316 struct buffer_head *dir_bh, 2343 struct buffer_head *dir_bh,
2317 char *orphan_name, 2344 char *orphan_name,
2318 struct inode **ret_orphan_dir, 2345 struct inode **ret_orphan_dir,
2319 u64 *ret_di_blkno, 2346 u64 *ret_di_blkno,
2320 struct ocfs2_dir_lookup_result *orphan_insert, 2347 struct ocfs2_dir_lookup_result *orphan_insert,
2321 struct ocfs2_alloc_context **ret_inode_ac) 2348 struct ocfs2_alloc_context **ret_inode_ac)
2322 { 2349 {
2323 int ret; 2350 int ret;
2324 u64 di_blkno; 2351 u64 di_blkno;
2325 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 2352 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2326 struct inode *orphan_dir = NULL; 2353 struct inode *orphan_dir = NULL;
2327 struct buffer_head *orphan_dir_bh = NULL; 2354 struct buffer_head *orphan_dir_bh = NULL;
2328 struct ocfs2_alloc_context *inode_ac = NULL; 2355 struct ocfs2_alloc_context *inode_ac = NULL;
2329 2356
2330 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh); 2357 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh);
2331 if (ret < 0) { 2358 if (ret < 0) {
2332 mlog_errno(ret); 2359 mlog_errno(ret);
2333 return ret; 2360 return ret;
2334 } 2361 }
2335 2362
2336 /* reserve an inode spot */ 2363 /* reserve an inode spot */
2337 ret = ocfs2_reserve_new_inode(osb, &inode_ac); 2364 ret = ocfs2_reserve_new_inode(osb, &inode_ac);
2338 if (ret < 0) { 2365 if (ret < 0) {
2339 if (ret != -ENOSPC) 2366 if (ret != -ENOSPC)
2340 mlog_errno(ret); 2367 mlog_errno(ret);
2341 goto out; 2368 goto out;
2342 } 2369 }
2343 2370
2344 ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac, 2371 ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac,
2345 &di_blkno); 2372 &di_blkno);
2346 if (ret) { 2373 if (ret) {
2347 mlog_errno(ret); 2374 mlog_errno(ret);
2348 goto out; 2375 goto out;
2349 } 2376 }
2350 2377
2351 ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh, 2378 ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh,
2352 di_blkno, orphan_name, orphan_insert); 2379 di_blkno, orphan_name, orphan_insert);
2353 if (ret < 0) { 2380 if (ret < 0) {
2354 mlog_errno(ret); 2381 mlog_errno(ret);
2355 goto out; 2382 goto out;
2356 } 2383 }
2357 2384
2358 out: 2385 out:
2359 if (ret == 0) { 2386 if (ret == 0) {
2360 *ret_orphan_dir = orphan_dir; 2387 *ret_orphan_dir = orphan_dir;
2361 *ret_di_blkno = di_blkno; 2388 *ret_di_blkno = di_blkno;
2362 *ret_inode_ac = inode_ac; 2389 *ret_inode_ac = inode_ac;
2363 /* 2390 /*
2364 * orphan_name and orphan_insert are already up to 2391 * orphan_name and orphan_insert are already up to
2365 * date via prepare_orphan_dir 2392 * date via prepare_orphan_dir
2366 */ 2393 */
2367 } else { 2394 } else {
2368 /* Unroll reserve_new_inode* */ 2395 /* Unroll reserve_new_inode* */
2369 if (inode_ac) 2396 if (inode_ac)
2370 ocfs2_free_alloc_context(inode_ac); 2397 ocfs2_free_alloc_context(inode_ac);
2371 2398
2372 /* Unroll orphan dir locking */ 2399 /* Unroll orphan dir locking */
2373 mutex_unlock(&orphan_dir->i_mutex); 2400 mutex_unlock(&orphan_dir->i_mutex);
2374 ocfs2_inode_unlock(orphan_dir, 1); 2401 ocfs2_inode_unlock(orphan_dir, 1);
2375 iput(orphan_dir); 2402 iput(orphan_dir);
2376 } 2403 }
2377 2404
2378 brelse(orphan_dir_bh); 2405 brelse(orphan_dir_bh);
2379 2406
2380 return ret; 2407 return ret;
2381 } 2408 }
2382 2409
2383 int ocfs2_create_inode_in_orphan(struct inode *dir, 2410 int ocfs2_create_inode_in_orphan(struct inode *dir,
2384 int mode, 2411 int mode,
2385 struct inode **new_inode) 2412 struct inode **new_inode)
2386 { 2413 {
2387 int status, did_quota_inode = 0; 2414 int status, did_quota_inode = 0;
2388 struct inode *inode = NULL; 2415 struct inode *inode = NULL;
2389 struct inode *orphan_dir = NULL; 2416 struct inode *orphan_dir = NULL;
2390 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 2417 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2391 struct ocfs2_dinode *di = NULL; 2418 struct ocfs2_dinode *di = NULL;
2392 handle_t *handle = NULL; 2419 handle_t *handle = NULL;
2393 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; 2420 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
2394 struct buffer_head *parent_di_bh = NULL; 2421 struct buffer_head *parent_di_bh = NULL;
2395 struct buffer_head *new_di_bh = NULL; 2422 struct buffer_head *new_di_bh = NULL;
2396 struct ocfs2_alloc_context *inode_ac = NULL; 2423 struct ocfs2_alloc_context *inode_ac = NULL;
2397 struct ocfs2_dir_lookup_result orphan_insert = { NULL, }; 2424 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2398 u64 uninitialized_var(di_blkno), suballoc_loc; 2425 u64 uninitialized_var(di_blkno), suballoc_loc;
2399 u16 suballoc_bit; 2426 u16 suballoc_bit;
2400 2427
2401 status = ocfs2_inode_lock(dir, &parent_di_bh, 1); 2428 status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2402 if (status < 0) { 2429 if (status < 0) {
2403 if (status != -ENOENT) 2430 if (status != -ENOENT)
2404 mlog_errno(status); 2431 mlog_errno(status);
2405 return status; 2432 return status;
2406 } 2433 }
2407 2434
2408 status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh, 2435 status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh,
2409 orphan_name, &orphan_dir, 2436 orphan_name, &orphan_dir,
2410 &di_blkno, &orphan_insert, &inode_ac); 2437 &di_blkno, &orphan_insert, &inode_ac);
2411 if (status < 0) { 2438 if (status < 0) {
2412 if (status != -ENOSPC) 2439 if (status != -ENOSPC)
2413 mlog_errno(status); 2440 mlog_errno(status);
2414 goto leave; 2441 goto leave;
2415 } 2442 }
2416 2443
2417 inode = ocfs2_get_init_inode(dir, mode); 2444 inode = ocfs2_get_init_inode(dir, mode);
2418 if (!inode) { 2445 if (!inode) {
2419 status = -ENOMEM; 2446 status = -ENOMEM;
2420 mlog_errno(status); 2447 mlog_errno(status);
2421 goto leave; 2448 goto leave;
2422 } 2449 }
2423 2450
2424 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0)); 2451 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0));
2425 if (IS_ERR(handle)) { 2452 if (IS_ERR(handle)) {
2426 status = PTR_ERR(handle); 2453 status = PTR_ERR(handle);
2427 handle = NULL; 2454 handle = NULL;
2428 mlog_errno(status); 2455 mlog_errno(status);
2429 goto leave; 2456 goto leave;
2430 } 2457 }
2431 2458
2432 status = dquot_alloc_inode(inode); 2459 status = dquot_alloc_inode(inode);
2433 if (status) 2460 if (status)
2434 goto leave; 2461 goto leave;
2435 did_quota_inode = 1; 2462 did_quota_inode = 1;
2436 2463
2437 status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac, 2464 status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac,
2438 &suballoc_loc, 2465 &suballoc_loc,
2439 &suballoc_bit, di_blkno); 2466 &suballoc_bit, di_blkno);
2440 if (status < 0) { 2467 if (status < 0) {
2441 mlog_errno(status); 2468 mlog_errno(status);
2442 goto leave; 2469 goto leave;
2443 } 2470 }
2444 2471
2445 clear_nlink(inode); 2472 clear_nlink(inode);
2446 /* do the real work now. */ 2473 /* do the real work now. */
2447 status = __ocfs2_mknod_locked(dir, inode, 2474 status = __ocfs2_mknod_locked(dir, inode,
2448 0, &new_di_bh, parent_di_bh, handle, 2475 0, &new_di_bh, parent_di_bh, handle,
2449 inode_ac, di_blkno, suballoc_loc, 2476 inode_ac, di_blkno, suballoc_loc,
2450 suballoc_bit); 2477 suballoc_bit);
2451 if (status < 0) { 2478 if (status < 0) {
2452 mlog_errno(status); 2479 mlog_errno(status);
2453 goto leave; 2480 goto leave;
2454 } 2481 }
2455 2482
2456 di = (struct ocfs2_dinode *)new_di_bh->b_data; 2483 di = (struct ocfs2_dinode *)new_di_bh->b_data;
2457 status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name, 2484 status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name,
2458 &orphan_insert, orphan_dir); 2485 &orphan_insert, orphan_dir);
2459 if (status < 0) { 2486 if (status < 0) {
2460 mlog_errno(status); 2487 mlog_errno(status);
2461 goto leave; 2488 goto leave;
2462 } 2489 }
2463 2490
2464 /* get open lock so that only nodes can't remove it from orphan dir. */ 2491 /* get open lock so that only nodes can't remove it from orphan dir. */
2465 status = ocfs2_open_lock(inode); 2492 status = ocfs2_open_lock(inode);
2466 if (status < 0) 2493 if (status < 0)
2467 mlog_errno(status); 2494 mlog_errno(status);
2468 2495
2469 insert_inode_hash(inode); 2496 insert_inode_hash(inode);
2470 leave: 2497 leave:
2471 if (status < 0 && did_quota_inode) 2498 if (status < 0 && did_quota_inode)
2472 dquot_free_inode(inode); 2499 dquot_free_inode(inode);
2473 if (handle) 2500 if (handle)
2474 ocfs2_commit_trans(osb, handle); 2501 ocfs2_commit_trans(osb, handle);
2475 2502
2476 if (orphan_dir) { 2503 if (orphan_dir) {
2477 /* This was locked for us in ocfs2_prepare_orphan_dir() */ 2504 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2478 ocfs2_inode_unlock(orphan_dir, 1); 2505 ocfs2_inode_unlock(orphan_dir, 1);
2479 mutex_unlock(&orphan_dir->i_mutex); 2506 mutex_unlock(&orphan_dir->i_mutex);
2480 iput(orphan_dir); 2507 iput(orphan_dir);
2481 } 2508 }
2482 2509
2483 if ((status < 0) && inode) { 2510 if ((status < 0) && inode) {
2484 clear_nlink(inode); 2511 clear_nlink(inode);
2485 iput(inode); 2512 iput(inode);
2486 } 2513 }
2487 2514
2488 if (inode_ac) 2515 if (inode_ac)
2489 ocfs2_free_alloc_context(inode_ac); 2516 ocfs2_free_alloc_context(inode_ac);
2490 2517
2491 brelse(new_di_bh); 2518 brelse(new_di_bh);
2492 2519
2493 if (!status) 2520 if (!status)
2494 *new_inode = inode; 2521 *new_inode = inode;
2495 2522
2496 ocfs2_free_dir_lookup_result(&orphan_insert); 2523 ocfs2_free_dir_lookup_result(&orphan_insert);
2497 2524
2498 ocfs2_inode_unlock(dir, 1); 2525 ocfs2_inode_unlock(dir, 1);
2499 brelse(parent_di_bh); 2526 brelse(parent_di_bh);
2500 return status; 2527 return status;
2501 } 2528 }
2502 2529
2503 int ocfs2_mv_orphaned_inode_to_new(struct inode *dir, 2530 int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
2504 struct inode *inode, 2531 struct inode *inode,
2505 struct dentry *dentry) 2532 struct dentry *dentry)
2506 { 2533 {
2507 int status = 0; 2534 int status = 0;
2508 struct buffer_head *parent_di_bh = NULL; 2535 struct buffer_head *parent_di_bh = NULL;
2509 handle_t *handle = NULL; 2536 handle_t *handle = NULL;
2510 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 2537 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2511 struct ocfs2_dinode *dir_di, *di; 2538 struct ocfs2_dinode *dir_di, *di;
2512 struct inode *orphan_dir_inode = NULL; 2539 struct inode *orphan_dir_inode = NULL;
2513 struct buffer_head *orphan_dir_bh = NULL; 2540 struct buffer_head *orphan_dir_bh = NULL;
2514 struct buffer_head *di_bh = NULL; 2541 struct buffer_head *di_bh = NULL;
2515 struct ocfs2_dir_lookup_result lookup = { NULL, }; 2542 struct ocfs2_dir_lookup_result lookup = { NULL, };
2516 2543
2517 trace_ocfs2_mv_orphaned_inode_to_new(dir, dentry, 2544 trace_ocfs2_mv_orphaned_inode_to_new(dir, dentry,
2518 dentry->d_name.len, dentry->d_name.name, 2545 dentry->d_name.len, dentry->d_name.name,
2519 (unsigned long long)OCFS2_I(dir)->ip_blkno, 2546 (unsigned long long)OCFS2_I(dir)->ip_blkno,
2520 (unsigned long long)OCFS2_I(inode)->ip_blkno); 2547 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2521 2548
2522 status = ocfs2_inode_lock(dir, &parent_di_bh, 1); 2549 status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2523 if (status < 0) { 2550 if (status < 0) {
2524 if (status != -ENOENT) 2551 if (status != -ENOENT)
2525 mlog_errno(status); 2552 mlog_errno(status);
2526 return status; 2553 return status;
2527 } 2554 }
2528 2555
2529 dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data; 2556 dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data;
2530 if (!dir_di->i_links_count) { 2557 if (!dir_di->i_links_count) {
2531 /* can't make a file in a deleted directory. */ 2558 /* can't make a file in a deleted directory. */
2532 status = -ENOENT; 2559 status = -ENOENT;
2533 goto leave; 2560 goto leave;
2534 } 2561 }
2535 2562
2536 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name, 2563 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
2537 dentry->d_name.len); 2564 dentry->d_name.len);
2538 if (status) 2565 if (status)
2539 goto leave; 2566 goto leave;
2540 2567
2541 /* get a spot inside the dir. */ 2568 /* get a spot inside the dir. */
2542 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh, 2569 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh,
2543 dentry->d_name.name, 2570 dentry->d_name.name,
2544 dentry->d_name.len, &lookup); 2571 dentry->d_name.len, &lookup);
2545 if (status < 0) { 2572 if (status < 0) {
2546 mlog_errno(status); 2573 mlog_errno(status);
2547 goto leave; 2574 goto leave;
2548 } 2575 }
2549 2576
2550 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 2577 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2551 ORPHAN_DIR_SYSTEM_INODE, 2578 ORPHAN_DIR_SYSTEM_INODE,
2552 osb->slot_num); 2579 osb->slot_num);
2553 if (!orphan_dir_inode) { 2580 if (!orphan_dir_inode) {
2554 status = -EEXIST; 2581 status = -EEXIST;
2555 mlog_errno(status); 2582 mlog_errno(status);
2556 goto leave; 2583 goto leave;
2557 } 2584 }
2558 2585
2559 mutex_lock(&orphan_dir_inode->i_mutex); 2586 mutex_lock(&orphan_dir_inode->i_mutex);
2560 2587
2561 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1); 2588 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2562 if (status < 0) { 2589 if (status < 0) {
2563 mlog_errno(status); 2590 mlog_errno(status);
2564 mutex_unlock(&orphan_dir_inode->i_mutex); 2591 mutex_unlock(&orphan_dir_inode->i_mutex);
2565 iput(orphan_dir_inode); 2592 iput(orphan_dir_inode);
2566 goto leave; 2593 goto leave;
2567 } 2594 }
2568 2595
2569 status = ocfs2_read_inode_block(inode, &di_bh); 2596 status = ocfs2_read_inode_block(inode, &di_bh);
2570 if (status < 0) { 2597 if (status < 0) {
2571 mlog_errno(status); 2598 mlog_errno(status);
2572 goto orphan_unlock; 2599 goto orphan_unlock;
2573 } 2600 }
2574 2601
2575 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb)); 2602 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
2576 if (IS_ERR(handle)) { 2603 if (IS_ERR(handle)) {
2577 status = PTR_ERR(handle); 2604 status = PTR_ERR(handle);
2578 handle = NULL; 2605 handle = NULL;
2579 mlog_errno(status); 2606 mlog_errno(status);
2580 goto orphan_unlock; 2607 goto orphan_unlock;
2581 } 2608 }
2582 2609
2583 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), 2610 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
2584 di_bh, OCFS2_JOURNAL_ACCESS_WRITE); 2611 di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
2585 if (status < 0) { 2612 if (status < 0) {
2586 mlog_errno(status); 2613 mlog_errno(status);
2587 goto out_commit; 2614 goto out_commit;
2588 } 2615 }
2589 2616
2590 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode, 2617 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
2591 orphan_dir_bh); 2618 orphan_dir_bh);
2592 if (status < 0) { 2619 if (status < 0) {
2593 mlog_errno(status); 2620 mlog_errno(status);
2594 goto out_commit; 2621 goto out_commit;
2595 } 2622 }
2596 2623
2597 di = (struct ocfs2_dinode *)di_bh->b_data; 2624 di = (struct ocfs2_dinode *)di_bh->b_data;
2598 di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL); 2625 di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL);
2599 di->i_orphaned_slot = 0; 2626 di->i_orphaned_slot = 0;
2600 set_nlink(inode, 1); 2627 set_nlink(inode, 1);
2601 ocfs2_set_links_count(di, inode->i_nlink); 2628 ocfs2_set_links_count(di, inode->i_nlink);
2602 ocfs2_update_inode_fsync_trans(handle, inode, 1); 2629 ocfs2_update_inode_fsync_trans(handle, inode, 1);
2603 ocfs2_journal_dirty(handle, di_bh); 2630 ocfs2_journal_dirty(handle, di_bh);
2604 2631
2605 status = ocfs2_add_entry(handle, dentry, inode, 2632 status = ocfs2_add_entry(handle, dentry, inode,
2606 OCFS2_I(inode)->ip_blkno, parent_di_bh, 2633 OCFS2_I(inode)->ip_blkno, parent_di_bh,
2607 &lookup); 2634 &lookup);
2608 if (status < 0) { 2635 if (status < 0) {
2609 mlog_errno(status); 2636 mlog_errno(status);
2610 goto out_commit; 2637 goto out_commit;
2611 } 2638 }
2612 2639
2613 status = ocfs2_dentry_attach_lock(dentry, inode, 2640 status = ocfs2_dentry_attach_lock(dentry, inode,
2614 OCFS2_I(dir)->ip_blkno); 2641 OCFS2_I(dir)->ip_blkno);
2615 if (status) { 2642 if (status) {
2616 mlog_errno(status); 2643 mlog_errno(status);
2617 goto out_commit; 2644 goto out_commit;
2618 } 2645 }
2619 2646
2620 d_instantiate(dentry, inode); 2647 d_instantiate(dentry, inode);
2621 status = 0; 2648 status = 0;
2622 out_commit: 2649 out_commit:
2623 ocfs2_commit_trans(osb, handle); 2650 ocfs2_commit_trans(osb, handle);
2624 orphan_unlock: 2651 orphan_unlock:
2625 ocfs2_inode_unlock(orphan_dir_inode, 1); 2652 ocfs2_inode_unlock(orphan_dir_inode, 1);
2626 mutex_unlock(&orphan_dir_inode->i_mutex); 2653 mutex_unlock(&orphan_dir_inode->i_mutex);
2627 iput(orphan_dir_inode); 2654 iput(orphan_dir_inode);
2628 leave: 2655 leave:
2629 2656
2630 ocfs2_inode_unlock(dir, 1); 2657 ocfs2_inode_unlock(dir, 1);
2631 2658
2632 brelse(di_bh); 2659 brelse(di_bh);
2633 brelse(parent_di_bh); 2660 brelse(parent_di_bh);
2634 brelse(orphan_dir_bh); 2661 brelse(orphan_dir_bh);
2635 2662
2636 ocfs2_free_dir_lookup_result(&lookup); 2663 ocfs2_free_dir_lookup_result(&lookup);
2637 2664
2638 if (status) 2665 if (status)
2639 mlog_errno(status); 2666 mlog_errno(status);
2640 2667
2641 return status; 2668 return status;
2642 } 2669 }
2643 2670
2644 const struct inode_operations ocfs2_dir_iops = { 2671 const struct inode_operations ocfs2_dir_iops = {
2645 .create = ocfs2_create, 2672 .create = ocfs2_create,
2646 .lookup = ocfs2_lookup, 2673 .lookup = ocfs2_lookup,
2647 .link = ocfs2_link, 2674 .link = ocfs2_link,
2648 .unlink = ocfs2_unlink, 2675 .unlink = ocfs2_unlink,
2649 .rmdir = ocfs2_unlink, 2676 .rmdir = ocfs2_unlink,
2650 .symlink = ocfs2_symlink, 2677 .symlink = ocfs2_symlink,
2651 .mkdir = ocfs2_mkdir, 2678 .mkdir = ocfs2_mkdir,
2652 .mknod = ocfs2_mknod, 2679 .mknod = ocfs2_mknod,
2653 .rename = ocfs2_rename, 2680 .rename = ocfs2_rename,
2654 .setattr = ocfs2_setattr, 2681 .setattr = ocfs2_setattr,
2655 .getattr = ocfs2_getattr, 2682 .getattr = ocfs2_getattr,
2656 .permission = ocfs2_permission, 2683 .permission = ocfs2_permission,
2657 .setxattr = generic_setxattr, 2684 .setxattr = generic_setxattr,
2658 .getxattr = generic_getxattr, 2685 .getxattr = generic_getxattr,
2659 .listxattr = ocfs2_listxattr, 2686 .listxattr = ocfs2_listxattr,
2660 .removexattr = generic_removexattr, 2687 .removexattr = generic_removexattr,
2661 .fiemap = ocfs2_fiemap, 2688 .fiemap = ocfs2_fiemap,
2662 .get_acl = ocfs2_iop_get_acl, 2689 .get_acl = ocfs2_iop_get_acl,
2663 .set_acl = ocfs2_iop_set_acl, 2690 .set_acl = ocfs2_iop_set_acl,
2664 }; 2691 };
2665 2692