blob: d5d808fe0140f7fb1e590c0255dd045542219bd1 [file] [log] [blame]
Mark Fashehccd979b2005-12-15 14:31:24 -08001/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * namei.c
5 *
6 * Create and rename file, directory, symlinks
7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 *
10 * Portions of this code from linux/fs/ext3/dir.c
11 *
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise pascal
15 * Universite Pierre et Marie Curie (Paris VI)
16 *
17 * from
18 *
19 * linux/fs/minix/dir.c
20 *
21 * Copyright (C) 1991, 1992 Linux Torvalds
22 *
23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public
25 * License as published by the Free Software Foundation; either
26 * version 2 of the License, or (at your option) any later version.
27 *
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * General Public License for more details.
32 *
33 * You should have received a copy of the GNU General Public
34 * License along with this program; if not, write to the
35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
36 * Boston, MA 021110-1307, USA.
37 */
38
39#include <linux/fs.h>
40#include <linux/types.h>
41#include <linux/slab.h>
42#include <linux/highmem.h>
43
44#define MLOG_MASK_PREFIX ML_NAMEI
45#include <cluster/masklog.h>
46
47#include "ocfs2.h"
48
49#include "alloc.h"
50#include "dcache.h"
51#include "dir.h"
52#include "dlmglue.h"
53#include "extent_map.h"
54#include "file.h"
55#include "inode.h"
56#include "journal.h"
57#include "namei.h"
58#include "suballoc.h"
Mark Fashehaa958872006-04-21 13:49:02 -070059#include "super.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080060#include "symlink.h"
61#include "sysfile.h"
62#include "uptodate.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080063
64#include "buffer_head_io.h"
65
Mark Fashehccd979b2005-12-15 14:31:24 -080066static int ocfs2_mknod_locked(struct ocfs2_super *osb,
67 struct inode *dir,
68 struct dentry *dentry, int mode,
69 dev_t dev,
70 struct buffer_head **new_fe_bh,
71 struct buffer_head *parent_fe_bh,
Mark Fasheh1fabe142006-10-09 18:11:45 -070072 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -080073 struct inode **ret_inode,
74 struct ocfs2_alloc_context *inode_ac);
75
Mark Fashehccd979b2005-12-15 14:31:24 -080076static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
Mark Fasheh5098c272006-10-05 18:12:57 -070077 struct inode **ret_orphan_dir,
Mark Fashehccd979b2005-12-15 14:31:24 -080078 struct inode *inode,
79 char *name,
80 struct buffer_head **de_bh);
81
82static int ocfs2_orphan_add(struct ocfs2_super *osb,
Mark Fasheh1fabe142006-10-09 18:11:45 -070083 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -080084 struct inode *inode,
85 struct ocfs2_dinode *fe,
86 char *name,
Mark Fasheh5098c272006-10-05 18:12:57 -070087 struct buffer_head *de_bh,
88 struct inode *orphan_dir_inode);
Mark Fashehccd979b2005-12-15 14:31:24 -080089
90static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
Mark Fasheh1fabe142006-10-09 18:11:45 -070091 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -080092 struct inode *inode,
93 const char *symname);
94
Mark Fashehccd979b2005-12-15 14:31:24 -080095/* An orphan dir name is an 8 byte value, printed as a hex string */
96#define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
97
98static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
99 struct nameidata *nd)
100{
101 int status;
102 u64 blkno;
Mark Fashehccd979b2005-12-15 14:31:24 -0800103 struct inode *inode = NULL;
104 struct dentry *ret;
Mark Fashehccd979b2005-12-15 14:31:24 -0800105 struct ocfs2_inode_info *oi;
106
107 mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
108 dentry->d_name.len, dentry->d_name.name);
109
110 if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
111 ret = ERR_PTR(-ENAMETOOLONG);
112 goto bail;
113 }
114
Mark Fashehb06970532006-03-03 10:24:33 -0800115 mlog(0, "find name %.*s in directory %llu\n", dentry->d_name.len,
116 dentry->d_name.name, (unsigned long long)OCFS2_I(dir)->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800117
Mark Fashehe63aecb62007-10-18 15:30:42 -0700118 status = ocfs2_inode_lock(dir, NULL, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800119 if (status < 0) {
120 if (status != -ENOENT)
121 mlog_errno(status);
122 ret = ERR_PTR(status);
123 goto bail;
124 }
125
Mark Fashehbe94d112007-09-11 15:22:06 -0700126 status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
127 dentry->d_name.len, &blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800128 if (status < 0)
129 goto bail_add;
130
Jan Kara5fa06132008-01-11 00:11:45 +0100131 inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800132 if (IS_ERR(inode)) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800133 ret = ERR_PTR(-EACCES);
134 goto bail_unlock;
135 }
136
137 oi = OCFS2_I(inode);
138 /* Clear any orphaned state... If we were able to look up the
139 * inode from a directory, it certainly can't be orphaned. We
140 * might have the bad state from a node which intended to
141 * orphan this inode but crashed before it could commit the
142 * unlink. */
143 spin_lock(&oi->ip_lock);
144 oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
Mark Fashehccd979b2005-12-15 14:31:24 -0800145 spin_unlock(&oi->ip_lock);
146
147bail_add:
Mark Fashehccd979b2005-12-15 14:31:24 -0800148 dentry->d_op = &ocfs2_dentry_ops;
149 ret = d_splice_alias(inode, dentry);
150
Mark Fasheh379dfe92006-09-08 14:21:03 -0700151 if (inode) {
152 /*
153 * If d_splice_alias() finds a DCACHE_DISCONNECTED
154 * dentry, it will d_move() it on top of ourse. The
155 * return value will indicate this however, so in
156 * those cases, we switch them around for the locking
157 * code.
158 *
159 * NOTE: This dentry already has ->d_op set from
160 * ocfs2_get_parent() and ocfs2_get_dentry()
161 */
162 if (ret)
163 dentry = ret;
164
165 status = ocfs2_dentry_attach_lock(dentry, inode,
Mark Fasheh0027dd52006-09-21 16:51:28 -0700166 OCFS2_I(dir)->ip_blkno);
Mark Fasheh379dfe92006-09-08 14:21:03 -0700167 if (status) {
168 mlog_errno(status);
169 ret = ERR_PTR(status);
170 goto bail_unlock;
171 }
172 }
173
Mark Fashehccd979b2005-12-15 14:31:24 -0800174bail_unlock:
175 /* Don't drop the cluster lock until *after* the d_add --
176 * unlink on another node will message us to remove that
177 * dentry under this lock so otherwise we can race this with
Mark Fasheh34d024f2007-09-24 15:56:19 -0700178 * the downconvert thread and have a stale dentry. */
Mark Fashehe63aecb62007-10-18 15:30:42 -0700179 ocfs2_inode_unlock(dir, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800180
181bail:
Mark Fashehccd979b2005-12-15 14:31:24 -0800182
183 mlog_exit_ptr(ret);
184
185 return ret;
186}
187
Mark Fashehccd979b2005-12-15 14:31:24 -0800188static int ocfs2_mknod(struct inode *dir,
189 struct dentry *dentry,
190 int mode,
191 dev_t dev)
192{
193 int status = 0;
194 struct buffer_head *parent_fe_bh = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700195 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800196 struct ocfs2_super *osb;
197 struct ocfs2_dinode *dirfe;
198 struct buffer_head *new_fe_bh = NULL;
199 struct buffer_head *de_bh = NULL;
200 struct inode *inode = NULL;
201 struct ocfs2_alloc_context *inode_ac = NULL;
202 struct ocfs2_alloc_context *data_ac = NULL;
203
204 mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
205 (unsigned long)dev, dentry->d_name.len,
206 dentry->d_name.name);
207
208 /* get our super block */
209 osb = OCFS2_SB(dir->i_sb);
210
Mark Fashehe63aecb62007-10-18 15:30:42 -0700211 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
Mark Fashehe3a82132006-10-05 16:04:17 -0700212 if (status < 0) {
213 if (status != -ENOENT)
214 mlog_errno(status);
215 return status;
216 }
217
Mark Fasheha663e302006-08-09 11:45:07 -0700218 if (S_ISDIR(mode) && (dir->i_nlink >= OCFS2_LINK_MAX)) {
219 status = -EMLINK;
220 goto leave;
221 }
222
Mark Fashehccd979b2005-12-15 14:31:24 -0800223 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
224 if (!dirfe->i_links_count) {
225 /* can't make a file in a deleted directory. */
226 status = -ENOENT;
227 goto leave;
228 }
229
230 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
231 dentry->d_name.len);
232 if (status)
233 goto leave;
234
235 /* get a spot inside the dir. */
236 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
237 dentry->d_name.name,
238 dentry->d_name.len, &de_bh);
239 if (status < 0) {
240 mlog_errno(status);
241 goto leave;
242 }
243
244 /* reserve an inode spot */
Mark Fashehda5cbf22006-10-06 18:34:35 -0700245 status = ocfs2_reserve_new_inode(osb, &inode_ac);
Mark Fashehccd979b2005-12-15 14:31:24 -0800246 if (status < 0) {
247 if (status != -ENOSPC)
248 mlog_errno(status);
249 goto leave;
250 }
251
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700252 /* Reserve a cluster if creating an extent based directory. */
253 if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
Mark Fashehda5cbf22006-10-06 18:34:35 -0700254 status = ocfs2_reserve_clusters(osb, 1, &data_ac);
Mark Fashehccd979b2005-12-15 14:31:24 -0800255 if (status < 0) {
256 if (status != -ENOSPC)
257 mlog_errno(status);
258 goto leave;
259 }
260 }
261
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700262 handle = ocfs2_start_trans(osb, OCFS2_MKNOD_CREDITS);
Mark Fashehccd979b2005-12-15 14:31:24 -0800263 if (IS_ERR(handle)) {
264 status = PTR_ERR(handle);
265 handle = NULL;
266 mlog_errno(status);
267 goto leave;
268 }
269
270 /* do the real work now. */
271 status = ocfs2_mknod_locked(osb, dir, dentry, mode, dev,
272 &new_fe_bh, parent_fe_bh, handle,
273 &inode, inode_ac);
274 if (status < 0) {
275 mlog_errno(status);
276 goto leave;
277 }
278
279 if (S_ISDIR(mode)) {
280 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
281 new_fe_bh, data_ac);
282 if (status < 0) {
283 mlog_errno(status);
284 goto leave;
285 }
286
287 status = ocfs2_journal_access(handle, dir, parent_fe_bh,
288 OCFS2_JOURNAL_ACCESS_WRITE);
289 if (status < 0) {
290 mlog_errno(status);
291 goto leave;
292 }
293 le16_add_cpu(&dirfe->i_links_count, 1);
294 status = ocfs2_journal_dirty(handle, parent_fe_bh);
295 if (status < 0) {
296 mlog_errno(status);
297 goto leave;
298 }
Dave Hansend8c76e62006-09-30 23:29:04 -0700299 inc_nlink(dir);
Mark Fashehccd979b2005-12-15 14:31:24 -0800300 }
301
302 status = ocfs2_add_entry(handle, dentry, inode,
303 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
304 de_bh);
305 if (status < 0) {
306 mlog_errno(status);
307 goto leave;
308 }
309
Mark Fasheh379dfe92006-09-08 14:21:03 -0700310 status = ocfs2_dentry_attach_lock(dentry, inode,
Mark Fasheh0027dd52006-09-21 16:51:28 -0700311 OCFS2_I(dir)->ip_blkno);
Mark Fasheh379dfe92006-09-08 14:21:03 -0700312 if (status) {
313 mlog_errno(status);
314 goto leave;
315 }
316
Mark Fashehccd979b2005-12-15 14:31:24 -0800317 insert_inode_hash(inode);
318 dentry->d_op = &ocfs2_dentry_ops;
319 d_instantiate(dentry, inode);
320 status = 0;
321leave:
322 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700323 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800324
Mark Fashehe63aecb62007-10-18 15:30:42 -0700325 ocfs2_inode_unlock(dir, 1);
Mark Fashehe3a82132006-10-05 16:04:17 -0700326
Mark Fashehccd979b2005-12-15 14:31:24 -0800327 if (status == -ENOSPC)
328 mlog(0, "Disk is full\n");
329
330 if (new_fe_bh)
331 brelse(new_fe_bh);
332
333 if (de_bh)
334 brelse(de_bh);
335
336 if (parent_fe_bh)
337 brelse(parent_fe_bh);
338
339 if ((status < 0) && inode)
340 iput(inode);
341
342 if (inode_ac)
343 ocfs2_free_alloc_context(inode_ac);
344
345 if (data_ac)
346 ocfs2_free_alloc_context(data_ac);
347
348 mlog_exit(status);
349
350 return status;
351}
352
353static int ocfs2_mknod_locked(struct ocfs2_super *osb,
354 struct inode *dir,
355 struct dentry *dentry, int mode,
356 dev_t dev,
357 struct buffer_head **new_fe_bh,
358 struct buffer_head *parent_fe_bh,
Mark Fasheh1fabe142006-10-09 18:11:45 -0700359 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -0800360 struct inode **ret_inode,
361 struct ocfs2_alloc_context *inode_ac)
362{
363 int status = 0;
364 struct ocfs2_dinode *fe = NULL;
365 struct ocfs2_extent_list *fel;
366 u64 fe_blkno = 0;
367 u16 suballoc_bit;
368 struct inode *inode = NULL;
369
370 mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
371 (unsigned long)dev, dentry->d_name.len,
372 dentry->d_name.name);
373
374 *new_fe_bh = NULL;
375 *ret_inode = NULL;
376
377 status = ocfs2_claim_new_inode(osb, handle, inode_ac, &suballoc_bit,
378 &fe_blkno);
379 if (status < 0) {
380 mlog_errno(status);
381 goto leave;
382 }
383
384 inode = new_inode(dir->i_sb);
385 if (IS_ERR(inode)) {
386 status = PTR_ERR(inode);
387 mlog(ML_ERROR, "new_inode failed!\n");
388 goto leave;
389 }
390
391 /* populate as many fields early on as possible - many of
392 * these are used by the support functions here and in
393 * callers. */
394 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
395 OCFS2_I(inode)->ip_blkno = fe_blkno;
396 if (S_ISDIR(mode))
397 inode->i_nlink = 2;
398 else
399 inode->i_nlink = 1;
400 inode->i_mode = mode;
401 spin_lock(&osb->osb_lock);
402 inode->i_generation = osb->s_next_generation++;
403 spin_unlock(&osb->osb_lock);
404
405 *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
406 if (!*new_fe_bh) {
407 status = -EIO;
408 mlog_errno(status);
409 goto leave;
410 }
411 ocfs2_set_new_buffer_uptodate(inode, *new_fe_bh);
412
413 status = ocfs2_journal_access(handle, inode, *new_fe_bh,
414 OCFS2_JOURNAL_ACCESS_CREATE);
415 if (status < 0) {
416 mlog_errno(status);
417 goto leave;
418 }
419
420 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
421 memset(fe, 0, osb->sb->s_blocksize);
422
423 fe->i_generation = cpu_to_le32(inode->i_generation);
424 fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
425 fe->i_blkno = cpu_to_le64(fe_blkno);
426 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
Tao Ma4d0ddb22008-03-05 16:11:46 +0800427 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
Mark Fashehccd979b2005-12-15 14:31:24 -0800428 fe->i_uid = cpu_to_le32(current->fsuid);
429 if (dir->i_mode & S_ISGID) {
430 fe->i_gid = cpu_to_le32(dir->i_gid);
431 if (S_ISDIR(mode))
432 mode |= S_ISGID;
433 } else
434 fe->i_gid = cpu_to_le32(current->fsgid);
435 fe->i_mode = cpu_to_le16(mode);
436 if (S_ISCHR(mode) || S_ISBLK(mode))
437 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
438
439 fe->i_links_count = cpu_to_le16(inode->i_nlink);
440
441 fe->i_last_eb_blk = 0;
442 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
443 le32_add_cpu(&fe->i_flags, OCFS2_VALID_FL);
444 fe->i_atime = fe->i_ctime = fe->i_mtime =
445 cpu_to_le64(CURRENT_TIME.tv_sec);
446 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
447 cpu_to_le32(CURRENT_TIME.tv_nsec);
448 fe->i_dtime = 0;
449
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700450 /*
451 * If supported, directories start with inline data.
452 */
453 if (S_ISDIR(mode) && ocfs2_supports_inline_data(osb)) {
454 u16 feat = le16_to_cpu(fe->i_dyn_features);
455
456 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
457
458 fe->id2.i_data.id_count = cpu_to_le16(ocfs2_max_inline_data(osb->sb));
459 } else {
460 fel = &fe->id2.i_list;
461 fel->l_tree_depth = 0;
462 fel->l_next_free_rec = 0;
463 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
464 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800465
466 status = ocfs2_journal_dirty(handle, *new_fe_bh);
467 if (status < 0) {
468 mlog_errno(status);
469 goto leave;
470 }
471
472 if (ocfs2_populate_inode(inode, fe, 1) < 0) {
473 mlog(ML_ERROR, "populate inode failed! bh->b_blocknr=%llu, "
Mark Fashehb06970532006-03-03 10:24:33 -0800474 "i_blkno=%llu, i_ino=%lu\n",
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700475 (unsigned long long)(*new_fe_bh)->b_blocknr,
476 (unsigned long long)le64_to_cpu(fe->i_blkno),
477 inode->i_ino);
Mark Fashehccd979b2005-12-15 14:31:24 -0800478 BUG();
479 }
480
481 ocfs2_inode_set_new(osb, inode);
Sunil Mushranc271c5c2006-12-05 17:56:35 -0800482 if (!ocfs2_mount_local(osb)) {
483 status = ocfs2_create_new_inode_locks(inode);
484 if (status < 0)
485 mlog_errno(status);
486 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800487
488 status = 0; /* error in ocfs2_create_new_inode_locks is not
489 * critical */
490
491 *ret_inode = inode;
492leave:
493 if (status < 0) {
494 if (*new_fe_bh) {
495 brelse(*new_fe_bh);
496 *new_fe_bh = NULL;
497 }
498 if (inode)
499 iput(inode);
500 }
501
502 mlog_exit(status);
503 return status;
504}
505
506static int ocfs2_mkdir(struct inode *dir,
507 struct dentry *dentry,
508 int mode)
509{
510 int ret;
511
512 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
513 dentry->d_name.len, dentry->d_name.name);
514 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
515 mlog_exit(ret);
516
517 return ret;
518}
519
520static int ocfs2_create(struct inode *dir,
521 struct dentry *dentry,
522 int mode,
523 struct nameidata *nd)
524{
525 int ret;
526
527 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
528 dentry->d_name.len, dentry->d_name.name);
529 ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
530 mlog_exit(ret);
531
532 return ret;
533}
534
535static int ocfs2_link(struct dentry *old_dentry,
536 struct inode *dir,
537 struct dentry *dentry)
538{
Mark Fasheh1fabe142006-10-09 18:11:45 -0700539 handle_t *handle;
Mark Fashehccd979b2005-12-15 14:31:24 -0800540 struct inode *inode = old_dentry->d_inode;
541 int err;
542 struct buffer_head *fe_bh = NULL;
543 struct buffer_head *parent_fe_bh = NULL;
544 struct buffer_head *de_bh = NULL;
545 struct ocfs2_dinode *fe = NULL;
546 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
547
548 mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode->i_ino,
549 old_dentry->d_name.len, old_dentry->d_name.name,
550 dentry->d_name.len, dentry->d_name.name);
551
Mark Fasheh123a9642006-10-05 16:48:23 -0700552 if (S_ISDIR(inode->i_mode))
553 return -EPERM;
Mark Fashehccd979b2005-12-15 14:31:24 -0800554
Mark Fashehe63aecb62007-10-18 15:30:42 -0700555 err = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800556 if (err < 0) {
557 if (err != -ENOENT)
558 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700559 return err;
Mark Fashehccd979b2005-12-15 14:31:24 -0800560 }
561
Tiger Yang0f62de22006-08-31 20:39:47 -0700562 if (!dir->i_nlink) {
563 err = -ENOENT;
Mark Fasheh123a9642006-10-05 16:48:23 -0700564 goto out;
Tiger Yang0f62de22006-08-31 20:39:47 -0700565 }
566
Mark Fashehccd979b2005-12-15 14:31:24 -0800567 err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
568 dentry->d_name.len);
569 if (err)
Mark Fasheh123a9642006-10-05 16:48:23 -0700570 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -0800571
572 err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
573 dentry->d_name.name,
574 dentry->d_name.len, &de_bh);
575 if (err < 0) {
576 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700577 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -0800578 }
579
Mark Fashehe63aecb62007-10-18 15:30:42 -0700580 err = ocfs2_inode_lock(inode, &fe_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800581 if (err < 0) {
582 if (err != -ENOENT)
583 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700584 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -0800585 }
586
587 fe = (struct ocfs2_dinode *) fe_bh->b_data;
588 if (le16_to_cpu(fe->i_links_count) >= OCFS2_LINK_MAX) {
589 err = -EMLINK;
Mark Fasheh123a9642006-10-05 16:48:23 -0700590 goto out_unlock_inode;
Mark Fashehccd979b2005-12-15 14:31:24 -0800591 }
592
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700593 handle = ocfs2_start_trans(osb, OCFS2_LINK_CREDITS);
Mark Fashehccd979b2005-12-15 14:31:24 -0800594 if (IS_ERR(handle)) {
595 err = PTR_ERR(handle);
596 handle = NULL;
597 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700598 goto out_unlock_inode;
Mark Fashehccd979b2005-12-15 14:31:24 -0800599 }
600
601 err = ocfs2_journal_access(handle, inode, fe_bh,
602 OCFS2_JOURNAL_ACCESS_WRITE);
603 if (err < 0) {
604 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700605 goto out_commit;
Mark Fashehccd979b2005-12-15 14:31:24 -0800606 }
607
Dave Hansend8c76e62006-09-30 23:29:04 -0700608 inc_nlink(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800609 inode->i_ctime = CURRENT_TIME;
610 fe->i_links_count = cpu_to_le16(inode->i_nlink);
611 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
612 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
613
614 err = ocfs2_journal_dirty(handle, fe_bh);
615 if (err < 0) {
616 le16_add_cpu(&fe->i_links_count, -1);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700617 drop_nlink(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800618 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700619 goto out_commit;
Mark Fashehccd979b2005-12-15 14:31:24 -0800620 }
621
622 err = ocfs2_add_entry(handle, dentry, inode,
623 OCFS2_I(inode)->ip_blkno,
624 parent_fe_bh, de_bh);
625 if (err) {
626 le16_add_cpu(&fe->i_links_count, -1);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700627 drop_nlink(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800628 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700629 goto out_commit;
Mark Fashehccd979b2005-12-15 14:31:24 -0800630 }
631
Mark Fasheh0027dd52006-09-21 16:51:28 -0700632 err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
Mark Fasheh379dfe92006-09-08 14:21:03 -0700633 if (err) {
634 mlog_errno(err);
Mark Fasheh123a9642006-10-05 16:48:23 -0700635 goto out_commit;
Mark Fasheh379dfe92006-09-08 14:21:03 -0700636 }
637
Mark Fashehccd979b2005-12-15 14:31:24 -0800638 atomic_inc(&inode->i_count);
639 dentry->d_op = &ocfs2_dentry_ops;
640 d_instantiate(dentry, inode);
Mark Fasheh123a9642006-10-05 16:48:23 -0700641
642out_commit:
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700643 ocfs2_commit_trans(osb, handle);
Mark Fasheh123a9642006-10-05 16:48:23 -0700644out_unlock_inode:
Mark Fashehe63aecb62007-10-18 15:30:42 -0700645 ocfs2_inode_unlock(inode, 1);
Mark Fasheh123a9642006-10-05 16:48:23 -0700646
647out:
Mark Fashehe63aecb62007-10-18 15:30:42 -0700648 ocfs2_inode_unlock(dir, 1);
Mark Fasheh123a9642006-10-05 16:48:23 -0700649
Mark Fashehccd979b2005-12-15 14:31:24 -0800650 if (de_bh)
651 brelse(de_bh);
652 if (fe_bh)
653 brelse(fe_bh);
654 if (parent_fe_bh)
655 brelse(parent_fe_bh);
656
657 mlog_exit(err);
658
659 return err;
660}
661
Mark Fasheh379dfe92006-09-08 14:21:03 -0700662/*
663 * Takes and drops an exclusive lock on the given dentry. This will
664 * force other nodes to drop it.
665 */
666static int ocfs2_remote_dentry_delete(struct dentry *dentry)
667{
668 int ret;
669
670 ret = ocfs2_dentry_lock(dentry, 1);
671 if (ret)
672 mlog_errno(ret);
673 else
674 ocfs2_dentry_unlock(dentry, 1);
675
676 return ret;
677}
678
Mark Fasheh17ff7852006-09-30 23:29:05 -0700679static inline int inode_is_unlinkable(struct inode *inode)
680{
681 if (S_ISDIR(inode->i_mode)) {
682 if (inode->i_nlink == 2)
683 return 1;
684 return 0;
685 }
686
687 if (inode->i_nlink == 1)
688 return 1;
689 return 0;
690}
691
Mark Fashehccd979b2005-12-15 14:31:24 -0800692static int ocfs2_unlink(struct inode *dir,
693 struct dentry *dentry)
694{
695 int status;
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700696 int child_locked = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800697 struct inode *inode = dentry->d_inode;
Mark Fasheh5098c272006-10-05 18:12:57 -0700698 struct inode *orphan_dir = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800699 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
700 u64 blkno;
701 struct ocfs2_dinode *fe = NULL;
702 struct buffer_head *fe_bh = NULL;
703 struct buffer_head *parent_node_bh = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700704 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800705 struct ocfs2_dir_entry *dirent = NULL;
706 struct buffer_head *dirent_bh = NULL;
707 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
708 struct buffer_head *orphan_entry_bh = NULL;
709
710 mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
711 dentry->d_name.len, dentry->d_name.name);
712
713 BUG_ON(dentry->d_parent->d_inode != dir);
714
Mark Fashehb06970532006-03-03 10:24:33 -0800715 mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800716
717 if (inode == osb->root_inode) {
718 mlog(0, "Cannot delete the root directory\n");
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700719 return -EPERM;
Mark Fashehccd979b2005-12-15 14:31:24 -0800720 }
721
Mark Fashehe63aecb62007-10-18 15:30:42 -0700722 status = ocfs2_inode_lock(dir, &parent_node_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800723 if (status < 0) {
724 if (status != -ENOENT)
725 mlog_errno(status);
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700726 return status;
Mark Fashehccd979b2005-12-15 14:31:24 -0800727 }
728
729 status = ocfs2_find_files_on_disk(dentry->d_name.name,
730 dentry->d_name.len, &blkno,
731 dir, &dirent_bh, &dirent);
732 if (status < 0) {
733 if (status != -ENOENT)
734 mlog_errno(status);
735 goto leave;
736 }
737
738 if (OCFS2_I(inode)->ip_blkno != blkno) {
739 status = -ENOENT;
740
Mark Fashehb06970532006-03-03 10:24:33 -0800741 mlog(0, "ip_blkno %llu != dirent blkno %llu ip_flags = %x\n",
742 (unsigned long long)OCFS2_I(inode)->ip_blkno,
743 (unsigned long long)blkno, OCFS2_I(inode)->ip_flags);
Mark Fashehccd979b2005-12-15 14:31:24 -0800744 goto leave;
745 }
746
Mark Fashehe63aecb62007-10-18 15:30:42 -0700747 status = ocfs2_inode_lock(inode, &fe_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800748 if (status < 0) {
749 if (status != -ENOENT)
750 mlog_errno(status);
751 goto leave;
752 }
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700753 child_locked = 1;
Mark Fashehccd979b2005-12-15 14:31:24 -0800754
755 if (S_ISDIR(inode->i_mode)) {
756 if (!ocfs2_empty_dir(inode)) {
757 status = -ENOTEMPTY;
758 goto leave;
759 } else if (inode->i_nlink != 2) {
760 status = -ENOTEMPTY;
761 goto leave;
762 }
763 }
764
Mark Fasheh379dfe92006-09-08 14:21:03 -0700765 status = ocfs2_remote_dentry_delete(dentry);
Mark Fashehccd979b2005-12-15 14:31:24 -0800766 if (status < 0) {
Mark Fasheh34d024f2007-09-24 15:56:19 -0700767 /* This remote delete should succeed under all normal
Mark Fashehccd979b2005-12-15 14:31:24 -0800768 * circumstances. */
769 mlog_errno(status);
770 goto leave;
771 }
772
Mark Fasheh17ff7852006-09-30 23:29:05 -0700773 if (inode_is_unlinkable(inode)) {
Mark Fasheh5098c272006-10-05 18:12:57 -0700774 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, inode,
Mark Fashehccd979b2005-12-15 14:31:24 -0800775 orphan_name,
776 &orphan_entry_bh);
777 if (status < 0) {
778 mlog_errno(status);
779 goto leave;
780 }
781 }
782
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700783 handle = ocfs2_start_trans(osb, OCFS2_UNLINK_CREDITS);
Mark Fashehccd979b2005-12-15 14:31:24 -0800784 if (IS_ERR(handle)) {
785 status = PTR_ERR(handle);
786 handle = NULL;
787 mlog_errno(status);
788 goto leave;
789 }
790
791 status = ocfs2_journal_access(handle, inode, fe_bh,
792 OCFS2_JOURNAL_ACCESS_WRITE);
793 if (status < 0) {
794 mlog_errno(status);
795 goto leave;
796 }
797
798 fe = (struct ocfs2_dinode *) fe_bh->b_data;
799
Mark Fasheh17ff7852006-09-30 23:29:05 -0700800 if (inode_is_unlinkable(inode)) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800801 status = ocfs2_orphan_add(osb, handle, inode, fe, orphan_name,
Mark Fasheh5098c272006-10-05 18:12:57 -0700802 orphan_entry_bh, orphan_dir);
Mark Fashehccd979b2005-12-15 14:31:24 -0800803 if (status < 0) {
804 mlog_errno(status);
805 goto leave;
806 }
807 }
808
809 /* delete the name from the parent dir */
810 status = ocfs2_delete_entry(handle, dir, dirent, dirent_bh);
811 if (status < 0) {
812 mlog_errno(status);
813 goto leave;
814 }
815
Mark Fasheh17ff7852006-09-30 23:29:05 -0700816 if (S_ISDIR(inode->i_mode))
817 drop_nlink(inode);
818 drop_nlink(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800819 fe->i_links_count = cpu_to_le16(inode->i_nlink);
Mark Fashehccd979b2005-12-15 14:31:24 -0800820
821 status = ocfs2_journal_dirty(handle, fe_bh);
822 if (status < 0) {
823 mlog_errno(status);
824 goto leave;
825 }
826
Mark Fasheh592282c2007-01-02 17:59:40 -0800827 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
828 if (S_ISDIR(inode->i_mode))
Mark Fasheh17ff7852006-09-30 23:29:05 -0700829 drop_nlink(dir);
Mark Fasheh592282c2007-01-02 17:59:40 -0800830
831 status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
832 if (status < 0) {
833 mlog_errno(status);
834 if (S_ISDIR(inode->i_mode))
Dave Hansend8c76e62006-09-30 23:29:04 -0700835 inc_nlink(dir);
Mark Fashehccd979b2005-12-15 14:31:24 -0800836 }
837
838leave:
Mark Fashehccd979b2005-12-15 14:31:24 -0800839 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700840 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800841
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700842 if (child_locked)
Mark Fashehe63aecb62007-10-18 15:30:42 -0700843 ocfs2_inode_unlock(inode, 1);
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700844
Mark Fashehe63aecb62007-10-18 15:30:42 -0700845 ocfs2_inode_unlock(dir, 1);
Mark Fasheh30a4f5e2006-10-06 11:49:45 -0700846
Mark Fasheh5098c272006-10-05 18:12:57 -0700847 if (orphan_dir) {
848 /* This was locked for us in ocfs2_prepare_orphan_dir() */
Mark Fashehe63aecb62007-10-18 15:30:42 -0700849 ocfs2_inode_unlock(orphan_dir, 1);
Mark Fasheh5098c272006-10-05 18:12:57 -0700850 mutex_unlock(&orphan_dir->i_mutex);
851 iput(orphan_dir);
852 }
853
Mark Fashehccd979b2005-12-15 14:31:24 -0800854 if (fe_bh)
855 brelse(fe_bh);
856
857 if (dirent_bh)
858 brelse(dirent_bh);
859
860 if (parent_node_bh)
861 brelse(parent_node_bh);
862
863 if (orphan_entry_bh)
864 brelse(orphan_entry_bh);
865
866 mlog_exit(status);
867
868 return status;
869}
870
871/*
872 * The only place this should be used is rename!
873 * if they have the same id, then the 1st one is the only one locked.
874 */
875static int ocfs2_double_lock(struct ocfs2_super *osb,
Mark Fashehccd979b2005-12-15 14:31:24 -0800876 struct buffer_head **bh1,
877 struct inode *inode1,
878 struct buffer_head **bh2,
879 struct inode *inode2)
880{
881 int status;
882 struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
883 struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
884 struct buffer_head **tmpbh;
885 struct inode *tmpinode;
886
Mark Fashehb06970532006-03-03 10:24:33 -0800887 mlog_entry("(inode1 = %llu, inode2 = %llu)\n",
888 (unsigned long long)oi1->ip_blkno,
889 (unsigned long long)oi2->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800890
Mark Fashehccd979b2005-12-15 14:31:24 -0800891 if (*bh1)
892 *bh1 = NULL;
893 if (*bh2)
894 *bh2 = NULL;
895
896 /* we always want to lock the one with the lower lockid first. */
897 if (oi1->ip_blkno != oi2->ip_blkno) {
898 if (oi1->ip_blkno < oi2->ip_blkno) {
899 /* switch id1 and id2 around */
900 mlog(0, "switching them around...\n");
901 tmpbh = bh2;
902 bh2 = bh1;
903 bh1 = tmpbh;
904
905 tmpinode = inode2;
906 inode2 = inode1;
907 inode1 = tmpinode;
908 }
909 /* lock id2 */
Mark Fashehe63aecb62007-10-18 15:30:42 -0700910 status = ocfs2_inode_lock(inode2, bh2, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800911 if (status < 0) {
912 if (status != -ENOENT)
913 mlog_errno(status);
914 goto bail;
915 }
916 }
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700917
Mark Fashehccd979b2005-12-15 14:31:24 -0800918 /* lock id1 */
Mark Fashehe63aecb62007-10-18 15:30:42 -0700919 status = ocfs2_inode_lock(inode1, bh1, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800920 if (status < 0) {
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700921 /*
922 * An error return must mean that no cluster locks
923 * were held on function exit.
924 */
925 if (oi1->ip_blkno != oi2->ip_blkno)
Mark Fashehe63aecb62007-10-18 15:30:42 -0700926 ocfs2_inode_unlock(inode2, 1);
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700927
Mark Fashehccd979b2005-12-15 14:31:24 -0800928 if (status != -ENOENT)
929 mlog_errno(status);
Mark Fashehccd979b2005-12-15 14:31:24 -0800930 }
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700931
Mark Fashehccd979b2005-12-15 14:31:24 -0800932bail:
933 mlog_exit(status);
934 return status;
935}
936
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700937static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
938{
Mark Fashehe63aecb62007-10-18 15:30:42 -0700939 ocfs2_inode_unlock(inode1, 1);
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700940
941 if (inode1 != inode2)
Mark Fashehe63aecb62007-10-18 15:30:42 -0700942 ocfs2_inode_unlock(inode2, 1);
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700943}
944
Mark Fashehccd979b2005-12-15 14:31:24 -0800945static int ocfs2_rename(struct inode *old_dir,
946 struct dentry *old_dentry,
947 struct inode *new_dir,
948 struct dentry *new_dentry)
949{
Mark Fasheh8d5596c2006-10-06 15:04:51 -0700950 int status = 0, rename_lock = 0, parents_locked = 0;
951 int old_child_locked = 0, new_child_locked = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800952 struct inode *old_inode = old_dentry->d_inode;
953 struct inode *new_inode = new_dentry->d_inode;
Mark Fasheh5098c272006-10-05 18:12:57 -0700954 struct inode *orphan_dir = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800955 struct ocfs2_dinode *newfe = NULL;
956 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
957 struct buffer_head *orphan_entry_bh = NULL;
958 struct buffer_head *newfe_bh = NULL;
Mark Fasheh592282c2007-01-02 17:59:40 -0800959 struct buffer_head *old_inode_bh = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800960 struct buffer_head *insert_entry_bh = NULL;
961 struct ocfs2_super *osb = NULL;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700962 u64 newfe_blkno, old_de_ino;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700963 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800964 struct buffer_head *old_dir_bh = NULL;
965 struct buffer_head *new_dir_bh = NULL;
Mark Fasheh38760e22007-09-11 17:21:56 -0700966 struct ocfs2_dir_entry *old_inode_dot_dot_de = NULL, *old_de = NULL,
967 *new_de = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800968 struct buffer_head *new_de_bh = NULL, *old_de_bh = NULL; // bhs for above
969 struct buffer_head *old_inode_de_bh = NULL; // if old_dentry is a dir,
970 // this is the 1st dirent bh
Mark Fasheh592282c2007-01-02 17:59:40 -0800971 nlink_t old_dir_nlink = old_dir->i_nlink;
Sunil Mushran480214d2007-08-06 15:11:56 -0700972 struct ocfs2_dinode *old_di;
Mark Fashehccd979b2005-12-15 14:31:24 -0800973
974 /* At some point it might be nice to break this function up a
975 * bit. */
976
977 mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p, from='%.*s' to='%.*s')\n",
978 old_dir, old_dentry, new_dir, new_dentry,
979 old_dentry->d_name.len, old_dentry->d_name.name,
980 new_dentry->d_name.len, new_dentry->d_name.name);
981
982 osb = OCFS2_SB(old_dir->i_sb);
983
984 if (new_inode) {
985 if (!igrab(new_inode))
986 BUG();
987 }
988
Uwe Kleine-König1b3c3712007-02-17 19:23:03 +0100989 /* Assume a directory hierarchy thusly:
Mark Fashehccd979b2005-12-15 14:31:24 -0800990 * a/b/c
991 * a/d
992 * a,b,c, and d are all directories.
993 *
994 * from cwd of 'a' on both nodes:
995 * node1: mv b/c d
996 * node2: mv d b/c
997 *
998 * And that's why, just like the VFS, we need a file system
999 * rename lock. */
Jan Kara5dabd692008-02-21 18:00:00 +01001000 if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
Mark Fashehccd979b2005-12-15 14:31:24 -08001001 status = ocfs2_rename_lock(osb);
1002 if (status < 0) {
1003 mlog_errno(status);
1004 goto bail;
1005 }
1006 rename_lock = 1;
1007 }
1008
Mark Fashehccd979b2005-12-15 14:31:24 -08001009 /* if old and new are the same, this'll just do one lock. */
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001010 status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1011 &new_dir_bh, new_dir);
Mark Fashehccd979b2005-12-15 14:31:24 -08001012 if (status < 0) {
1013 mlog_errno(status);
1014 goto bail;
1015 }
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001016 parents_locked = 1;
Mark Fashehccd979b2005-12-15 14:31:24 -08001017
1018 /* make sure both dirs have bhs
1019 * get an extra ref on old_dir_bh if old==new */
1020 if (!new_dir_bh) {
1021 if (old_dir_bh) {
1022 new_dir_bh = old_dir_bh;
1023 get_bh(new_dir_bh);
1024 } else {
1025 mlog(ML_ERROR, "no old_dir_bh!\n");
1026 status = -EIO;
1027 goto bail;
1028 }
1029 }
1030
Mark Fasheh379dfe92006-09-08 14:21:03 -07001031 /*
Mark Fasheh592282c2007-01-02 17:59:40 -08001032 * Aside from allowing a meta data update, the locking here
Mark Fasheh34d024f2007-09-24 15:56:19 -07001033 * also ensures that the downconvert thread on other nodes
1034 * won't have to concurrently downconvert the inode and the
1035 * dentry locks.
Mark Fasheh379dfe92006-09-08 14:21:03 -07001036 */
Mark Fashehe63aecb62007-10-18 15:30:42 -07001037 status = ocfs2_inode_lock(old_inode, &old_inode_bh, 1);
Mark Fasheh379dfe92006-09-08 14:21:03 -07001038 if (status < 0) {
1039 if (status != -ENOENT)
Mark Fashehccd979b2005-12-15 14:31:24 -08001040 mlog_errno(status);
Mark Fasheh379dfe92006-09-08 14:21:03 -07001041 goto bail;
1042 }
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001043 old_child_locked = 1;
Mark Fashehccd979b2005-12-15 14:31:24 -08001044
Mark Fasheh379dfe92006-09-08 14:21:03 -07001045 status = ocfs2_remote_dentry_delete(old_dentry);
1046 if (status < 0) {
1047 mlog_errno(status);
1048 goto bail;
1049 }
1050
1051 if (S_ISDIR(old_inode->i_mode)) {
Mark Fasheh38760e22007-09-11 17:21:56 -07001052 u64 old_inode_parent;
Mark Fashehccd979b2005-12-15 14:31:24 -08001053
Mark Fasheh38760e22007-09-11 17:21:56 -07001054 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1055 old_inode, &old_inode_de_bh,
1056 &old_inode_dot_dot_de);
1057 if (status) {
1058 status = -EIO;
Mark Fashehccd979b2005-12-15 14:31:24 -08001059 goto bail;
Mark Fasheh38760e22007-09-11 17:21:56 -07001060 }
1061
1062 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1063 status = -EIO;
Mark Fashehccd979b2005-12-15 14:31:24 -08001064 goto bail;
Mark Fasheh38760e22007-09-11 17:21:56 -07001065 }
1066
1067 if (!new_inode && new_dir != old_dir &&
1068 new_dir->i_nlink >= OCFS2_LINK_MAX) {
1069 status = -EMLINK;
1070 goto bail;
1071 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001072 }
1073
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001074 status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1075 old_dentry->d_name.len,
1076 &old_de_ino);
1077 if (status) {
1078 status = -ENOENT;
Mark Fashehccd979b2005-12-15 14:31:24 -08001079 goto bail;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001080 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001081
1082 /*
1083 * Check for inode number is _not_ due to possible IO errors.
1084 * We might rmdir the source, keep it as pwd of some process
1085 * and merrily kill the link to whatever was created under the
1086 * same name. Goodbye sticky bit ;-<
1087 */
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001088 if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1089 status = -ENOENT;
Mark Fashehccd979b2005-12-15 14:31:24 -08001090 goto bail;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001091 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001092
1093 /* check if the target already exists (in which case we need
1094 * to delete it */
1095 status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1096 new_dentry->d_name.len,
1097 &newfe_blkno, new_dir, &new_de_bh,
1098 &new_de);
1099 /* The only error we allow here is -ENOENT because the new
1100 * file not existing is perfectly valid. */
1101 if ((status < 0) && (status != -ENOENT)) {
1102 /* If we cannot find the file specified we should just */
1103 /* return the error... */
1104 mlog_errno(status);
1105 goto bail;
1106 }
1107
Srinivas Eedae325a882007-10-31 16:49:43 -07001108 if (!new_de && new_inode) {
1109 /*
1110 * Target was unlinked by another node while we were
1111 * waiting to get to ocfs2_rename(). There isn't
1112 * anything we can do here to help the situation, so
1113 * bubble up the appropriate error.
1114 */
1115 status = -ENOENT;
1116 goto bail;
1117 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001118
1119 /* In case we need to overwrite an existing file, we blow it
1120 * away first */
1121 if (new_de) {
1122 /* VFS didn't think there existed an inode here, but
1123 * someone else in the cluster must have raced our
1124 * rename to create one. Today we error cleanly, in
1125 * the future we should consider calling iget to build
1126 * a new struct inode for this entry. */
1127 if (!new_inode) {
1128 status = -EACCES;
1129
1130 mlog(0, "We found an inode for name %.*s but VFS "
1131 "didn't give us one.\n", new_dentry->d_name.len,
1132 new_dentry->d_name.name);
1133 goto bail;
1134 }
1135
1136 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1137 status = -EACCES;
1138
Mark Fashehb06970532006-03-03 10:24:33 -08001139 mlog(0, "Inode %llu and dir %llu disagree. flags = %x\n",
1140 (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1141 (unsigned long long)newfe_blkno,
Mark Fashehccd979b2005-12-15 14:31:24 -08001142 OCFS2_I(new_inode)->ip_flags);
1143 goto bail;
1144 }
1145
Mark Fashehe63aecb62007-10-18 15:30:42 -07001146 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001147 if (status < 0) {
1148 if (status != -ENOENT)
1149 mlog_errno(status);
1150 goto bail;
1151 }
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001152 new_child_locked = 1;
Mark Fashehccd979b2005-12-15 14:31:24 -08001153
Mark Fasheh379dfe92006-09-08 14:21:03 -07001154 status = ocfs2_remote_dentry_delete(new_dentry);
Mark Fashehccd979b2005-12-15 14:31:24 -08001155 if (status < 0) {
1156 mlog_errno(status);
1157 goto bail;
1158 }
1159
1160 newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1161
Mark Fashehb06970532006-03-03 10:24:33 -08001162 mlog(0, "aha rename over existing... new_de=%p new_blkno=%llu "
1163 "newfebh=%p bhblocknr=%llu\n", new_de,
1164 (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
Mark Fashehccd979b2005-12-15 14:31:24 -08001165 (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1166
1167 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
Mark Fasheh5098c272006-10-05 18:12:57 -07001168 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
Mark Fashehccd979b2005-12-15 14:31:24 -08001169 new_inode,
1170 orphan_name,
1171 &orphan_entry_bh);
1172 if (status < 0) {
1173 mlog_errno(status);
1174 goto bail;
1175 }
1176 }
1177 } else {
1178 BUG_ON(new_dentry->d_parent->d_inode != new_dir);
1179
1180 status = ocfs2_check_dir_for_entry(new_dir,
1181 new_dentry->d_name.name,
1182 new_dentry->d_name.len);
1183 if (status)
1184 goto bail;
1185
1186 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1187 new_dentry->d_name.name,
1188 new_dentry->d_name.len,
1189 &insert_entry_bh);
1190 if (status < 0) {
1191 mlog_errno(status);
1192 goto bail;
1193 }
1194 }
1195
Mark Fasheh65eff9c2006-10-09 17:26:22 -07001196 handle = ocfs2_start_trans(osb, OCFS2_RENAME_CREDITS);
Mark Fashehccd979b2005-12-15 14:31:24 -08001197 if (IS_ERR(handle)) {
1198 status = PTR_ERR(handle);
1199 handle = NULL;
1200 mlog_errno(status);
1201 goto bail;
1202 }
1203
1204 if (new_de) {
1205 if (S_ISDIR(new_inode->i_mode)) {
1206 if (!ocfs2_empty_dir(new_inode) ||
1207 new_inode->i_nlink != 2) {
1208 status = -ENOTEMPTY;
1209 goto bail;
1210 }
1211 }
1212 status = ocfs2_journal_access(handle, new_inode, newfe_bh,
1213 OCFS2_JOURNAL_ACCESS_WRITE);
1214 if (status < 0) {
1215 mlog_errno(status);
1216 goto bail;
1217 }
1218
1219 if (S_ISDIR(new_inode->i_mode) ||
1220 (newfe->i_links_count == cpu_to_le16(1))){
1221 status = ocfs2_orphan_add(osb, handle, new_inode,
1222 newfe, orphan_name,
Mark Fasheh5098c272006-10-05 18:12:57 -07001223 orphan_entry_bh, orphan_dir);
Mark Fashehccd979b2005-12-15 14:31:24 -08001224 if (status < 0) {
1225 mlog_errno(status);
1226 goto bail;
1227 }
1228 }
1229
1230 /* change the dirent to point to the correct inode */
Mark Fasheh38760e22007-09-11 17:21:56 -07001231 status = ocfs2_update_entry(new_dir, handle, new_de_bh,
1232 new_de, old_inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001233 if (status < 0) {
1234 mlog_errno(status);
1235 goto bail;
1236 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001237 new_dir->i_version++;
Mark Fashehccd979b2005-12-15 14:31:24 -08001238
1239 if (S_ISDIR(new_inode->i_mode))
1240 newfe->i_links_count = 0;
1241 else
1242 le16_add_cpu(&newfe->i_links_count, -1);
1243
1244 status = ocfs2_journal_dirty(handle, newfe_bh);
1245 if (status < 0) {
1246 mlog_errno(status);
1247 goto bail;
1248 }
1249 } else {
1250 /* if the name was not found in new_dir, add it now */
1251 status = ocfs2_add_entry(handle, new_dentry, old_inode,
1252 OCFS2_I(old_inode)->ip_blkno,
1253 new_dir_bh, insert_entry_bh);
1254 }
1255
1256 old_inode->i_ctime = CURRENT_TIME;
1257 mark_inode_dirty(old_inode);
Sunil Mushran480214d2007-08-06 15:11:56 -07001258
1259 status = ocfs2_journal_access(handle, old_inode, old_inode_bh,
1260 OCFS2_JOURNAL_ACCESS_WRITE);
1261 if (status >= 0) {
1262 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1263
1264 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
1265 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1266
1267 status = ocfs2_journal_dirty(handle, old_inode_bh);
1268 if (status < 0)
1269 mlog_errno(status);
1270 } else
1271 mlog_errno(status);
Mark Fashehccd979b2005-12-15 14:31:24 -08001272
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001273 /*
1274 * Now that the name has been added to new_dir, remove the old name.
1275 *
1276 * We don't keep any directory entry context around until now
1277 * because the insert might have changed the type of directory
1278 * we're dealing with.
1279 */
1280 old_de_bh = ocfs2_find_entry(old_dentry->d_name.name,
1281 old_dentry->d_name.len,
1282 old_dir, &old_de);
1283 if (!old_de_bh) {
1284 status = -EIO;
1285 goto bail;
1286 }
1287
Mark Fashehccd979b2005-12-15 14:31:24 -08001288 status = ocfs2_delete_entry(handle, old_dir, old_de, old_de_bh);
1289 if (status < 0) {
1290 mlog_errno(status);
1291 goto bail;
1292 }
1293
1294 if (new_inode) {
1295 new_inode->i_nlink--;
1296 new_inode->i_ctime = CURRENT_TIME;
1297 }
1298 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1299 if (old_inode_de_bh) {
Mark Fasheh38760e22007-09-11 17:21:56 -07001300 status = ocfs2_update_entry(old_inode, handle, old_inode_de_bh,
1301 old_inode_dot_dot_de, new_dir);
Mark Fashehccd979b2005-12-15 14:31:24 -08001302 old_dir->i_nlink--;
1303 if (new_inode) {
1304 new_inode->i_nlink--;
1305 } else {
Dave Hansend8c76e62006-09-30 23:29:04 -07001306 inc_nlink(new_dir);
Mark Fashehccd979b2005-12-15 14:31:24 -08001307 mark_inode_dirty(new_dir);
1308 }
1309 }
1310 mark_inode_dirty(old_dir);
Mark Fasheh592282c2007-01-02 17:59:40 -08001311 ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1312 if (new_inode) {
Mark Fashehccd979b2005-12-15 14:31:24 -08001313 mark_inode_dirty(new_inode);
Mark Fasheh592282c2007-01-02 17:59:40 -08001314 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1315 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001316
Mark Fasheh592282c2007-01-02 17:59:40 -08001317 if (old_dir != new_dir) {
1318 /* Keep the same times on both directories.*/
1319 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1320
1321 /*
1322 * This will also pick up the i_nlink change from the
1323 * block above.
1324 */
1325 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1326 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001327
1328 if (old_dir_nlink != old_dir->i_nlink) {
1329 if (!old_dir_bh) {
1330 mlog(ML_ERROR, "need to change nlink for old dir "
Mark Fashehb06970532006-03-03 10:24:33 -08001331 "%llu from %d to %d but bh is NULL!\n",
1332 (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1333 (int)old_dir_nlink, old_dir->i_nlink);
Mark Fashehccd979b2005-12-15 14:31:24 -08001334 } else {
1335 struct ocfs2_dinode *fe;
1336 status = ocfs2_journal_access(handle, old_dir,
1337 old_dir_bh,
1338 OCFS2_JOURNAL_ACCESS_WRITE);
1339 fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1340 fe->i_links_count = cpu_to_le16(old_dir->i_nlink);
1341 status = ocfs2_journal_dirty(handle, old_dir_bh);
1342 }
1343 }
1344
Mark Fasheh379dfe92006-09-08 14:21:03 -07001345 ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
Mark Fashehccd979b2005-12-15 14:31:24 -08001346 status = 0;
1347bail:
1348 if (rename_lock)
1349 ocfs2_rename_unlock(osb);
1350
1351 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001352 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001353
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001354 if (parents_locked)
1355 ocfs2_double_unlock(old_dir, new_dir);
1356
1357 if (old_child_locked)
Mark Fashehe63aecb62007-10-18 15:30:42 -07001358 ocfs2_inode_unlock(old_inode, 1);
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001359
1360 if (new_child_locked)
Mark Fashehe63aecb62007-10-18 15:30:42 -07001361 ocfs2_inode_unlock(new_inode, 1);
Mark Fasheh8d5596c2006-10-06 15:04:51 -07001362
Mark Fasheh5098c272006-10-05 18:12:57 -07001363 if (orphan_dir) {
1364 /* This was locked for us in ocfs2_prepare_orphan_dir() */
Mark Fashehe63aecb62007-10-18 15:30:42 -07001365 ocfs2_inode_unlock(orphan_dir, 1);
Mark Fasheh5098c272006-10-05 18:12:57 -07001366 mutex_unlock(&orphan_dir->i_mutex);
1367 iput(orphan_dir);
1368 }
1369
Mark Fashehccd979b2005-12-15 14:31:24 -08001370 if (new_inode)
1371 sync_mapping_buffers(old_inode->i_mapping);
1372
1373 if (new_inode)
1374 iput(new_inode);
1375 if (newfe_bh)
1376 brelse(newfe_bh);
Mark Fasheh592282c2007-01-02 17:59:40 -08001377 if (old_inode_bh)
1378 brelse(old_inode_bh);
Mark Fashehccd979b2005-12-15 14:31:24 -08001379 if (old_dir_bh)
1380 brelse(old_dir_bh);
1381 if (new_dir_bh)
1382 brelse(new_dir_bh);
1383 if (new_de_bh)
1384 brelse(new_de_bh);
1385 if (old_de_bh)
1386 brelse(old_de_bh);
1387 if (old_inode_de_bh)
1388 brelse(old_inode_de_bh);
1389 if (orphan_entry_bh)
1390 brelse(orphan_entry_bh);
1391 if (insert_entry_bh)
1392 brelse(insert_entry_bh);
1393
1394 mlog_exit(status);
1395
1396 return status;
1397}
1398
1399/*
1400 * we expect i_size = strlen(symname). Copy symname into the file
1401 * data, including the null terminator.
1402 */
1403static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
Mark Fasheh1fabe142006-10-09 18:11:45 -07001404 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -08001405 struct inode *inode,
1406 const char *symname)
1407{
1408 struct buffer_head **bhs = NULL;
1409 const char *c;
1410 struct super_block *sb = osb->sb;
Mark Fasheh4f902c32007-03-09 16:26:50 -08001411 u64 p_blkno, p_blocks;
Mark Fashehccd979b2005-12-15 14:31:24 -08001412 int virtual, blocks, status, i, bytes_left;
1413
1414 bytes_left = i_size_read(inode) + 1;
1415 /* we can't trust i_blocks because we're actually going to
1416 * write i_size + 1 bytes. */
1417 blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1418
Andrew Morton5515eff2006-03-26 01:37:53 -08001419 mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
1420 (unsigned long long)inode->i_blocks,
1421 i_size_read(inode), blocks);
Mark Fashehccd979b2005-12-15 14:31:24 -08001422
1423 /* Sanity check -- make sure we're going to fit. */
1424 if (bytes_left >
1425 ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1426 status = -EIO;
1427 mlog_errno(status);
1428 goto bail;
1429 }
1430
1431 bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1432 if (!bhs) {
1433 status = -ENOMEM;
1434 mlog_errno(status);
1435 goto bail;
1436 }
1437
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001438 status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1439 NULL);
Mark Fashehccd979b2005-12-15 14:31:24 -08001440 if (status < 0) {
1441 mlog_errno(status);
1442 goto bail;
1443 }
1444
1445 /* links can never be larger than one cluster so we know this
1446 * is all going to be contiguous, but do a sanity check
1447 * anyway. */
1448 if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1449 status = -EIO;
1450 mlog_errno(status);
1451 goto bail;
1452 }
1453
1454 virtual = 0;
1455 while(bytes_left > 0) {
1456 c = &symname[virtual * sb->s_blocksize];
1457
1458 bhs[virtual] = sb_getblk(sb, p_blkno);
1459 if (!bhs[virtual]) {
1460 status = -ENOMEM;
1461 mlog_errno(status);
1462 goto bail;
1463 }
1464 ocfs2_set_new_buffer_uptodate(inode, bhs[virtual]);
1465
1466 status = ocfs2_journal_access(handle, inode, bhs[virtual],
1467 OCFS2_JOURNAL_ACCESS_CREATE);
1468 if (status < 0) {
1469 mlog_errno(status);
1470 goto bail;
1471 }
1472
1473 memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1474
1475 memcpy(bhs[virtual]->b_data, c,
1476 (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1477 bytes_left);
1478
1479 status = ocfs2_journal_dirty(handle, bhs[virtual]);
1480 if (status < 0) {
1481 mlog_errno(status);
1482 goto bail;
1483 }
1484
1485 virtual++;
1486 p_blkno++;
1487 bytes_left -= sb->s_blocksize;
1488 }
1489
1490 status = 0;
1491bail:
1492
1493 if (bhs) {
1494 for(i = 0; i < blocks; i++)
1495 if (bhs[i])
1496 brelse(bhs[i]);
1497 kfree(bhs);
1498 }
1499
1500 mlog_exit(status);
1501 return status;
1502}
1503
1504static int ocfs2_symlink(struct inode *dir,
1505 struct dentry *dentry,
1506 const char *symname)
1507{
1508 int status, l, credits;
1509 u64 newsize;
1510 struct ocfs2_super *osb = NULL;
1511 struct inode *inode = NULL;
1512 struct super_block *sb;
1513 struct buffer_head *new_fe_bh = NULL;
1514 struct buffer_head *de_bh = NULL;
1515 struct buffer_head *parent_fe_bh = NULL;
1516 struct ocfs2_dinode *fe = NULL;
1517 struct ocfs2_dinode *dirfe;
Mark Fasheh1fabe142006-10-09 18:11:45 -07001518 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -08001519 struct ocfs2_alloc_context *inode_ac = NULL;
1520 struct ocfs2_alloc_context *data_ac = NULL;
1521
1522 mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir,
1523 dentry, symname, dentry->d_name.len, dentry->d_name.name);
1524
1525 sb = dir->i_sb;
1526 osb = OCFS2_SB(sb);
1527
1528 l = strlen(symname) + 1;
1529
1530 credits = ocfs2_calc_symlink_credits(sb);
1531
Mark Fashehccd979b2005-12-15 14:31:24 -08001532 /* lock the parent directory */
Mark Fashehe63aecb62007-10-18 15:30:42 -07001533 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001534 if (status < 0) {
1535 if (status != -ENOENT)
1536 mlog_errno(status);
Mark Fasheh6d8fc402006-10-06 11:54:33 -07001537 return status;
Mark Fashehccd979b2005-12-15 14:31:24 -08001538 }
1539
1540 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1541 if (!dirfe->i_links_count) {
1542 /* can't make a file in a deleted directory. */
1543 status = -ENOENT;
1544 goto bail;
1545 }
1546
1547 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1548 dentry->d_name.len);
1549 if (status)
1550 goto bail;
1551
1552 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1553 dentry->d_name.name,
1554 dentry->d_name.len, &de_bh);
1555 if (status < 0) {
1556 mlog_errno(status);
1557 goto bail;
1558 }
1559
Mark Fashehda5cbf22006-10-06 18:34:35 -07001560 status = ocfs2_reserve_new_inode(osb, &inode_ac);
Mark Fashehccd979b2005-12-15 14:31:24 -08001561 if (status < 0) {
1562 if (status != -ENOSPC)
1563 mlog_errno(status);
1564 goto bail;
1565 }
1566
1567 /* don't reserve bitmap space for fast symlinks. */
1568 if (l > ocfs2_fast_symlink_chars(sb)) {
Mark Fashehda5cbf22006-10-06 18:34:35 -07001569 status = ocfs2_reserve_clusters(osb, 1, &data_ac);
Mark Fashehccd979b2005-12-15 14:31:24 -08001570 if (status < 0) {
1571 if (status != -ENOSPC)
1572 mlog_errno(status);
1573 goto bail;
1574 }
1575 }
1576
Mark Fasheh65eff9c2006-10-09 17:26:22 -07001577 handle = ocfs2_start_trans(osb, credits);
Mark Fashehccd979b2005-12-15 14:31:24 -08001578 if (IS_ERR(handle)) {
1579 status = PTR_ERR(handle);
1580 handle = NULL;
1581 mlog_errno(status);
1582 goto bail;
1583 }
1584
1585 status = ocfs2_mknod_locked(osb, dir, dentry,
1586 S_IFLNK | S_IRWXUGO, 0,
1587 &new_fe_bh, parent_fe_bh, handle,
1588 &inode, inode_ac);
1589 if (status < 0) {
1590 mlog_errno(status);
1591 goto bail;
1592 }
1593
1594 fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1595 inode->i_rdev = 0;
1596 newsize = l - 1;
1597 if (l > ocfs2_fast_symlink_chars(sb)) {
Mark Fashehdcd05382007-01-16 11:32:23 -08001598 u32 offset = 0;
1599
Mark Fashehccd979b2005-12-15 14:31:24 -08001600 inode->i_op = &ocfs2_symlink_inode_operations;
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001601 status = ocfs2_do_extend_allocation(osb, inode, &offset, 1, 0,
Mark Fashehdcd05382007-01-16 11:32:23 -08001602 new_fe_bh,
Mark Fashehccd979b2005-12-15 14:31:24 -08001603 handle, data_ac, NULL,
1604 NULL);
1605 if (status < 0) {
1606 if (status != -ENOSPC && status != -EINTR) {
Mark Fashehb06970532006-03-03 10:24:33 -08001607 mlog(ML_ERROR,
1608 "Failed to extend file to %llu\n",
1609 (unsigned long long)newsize);
Mark Fashehccd979b2005-12-15 14:31:24 -08001610 mlog_errno(status);
1611 status = -ENOSPC;
1612 }
1613 goto bail;
1614 }
1615 i_size_write(inode, newsize);
Mark Fasheh8110b072007-03-22 16:53:23 -07001616 inode->i_blocks = ocfs2_inode_sector_count(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001617 } else {
1618 inode->i_op = &ocfs2_fast_symlink_inode_operations;
1619 memcpy((char *) fe->id2.i_symlink, symname, l);
1620 i_size_write(inode, newsize);
1621 inode->i_blocks = 0;
1622 }
1623
1624 status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1625 if (status < 0) {
1626 mlog_errno(status);
1627 goto bail;
1628 }
1629
1630 if (!ocfs2_inode_is_fast_symlink(inode)) {
1631 status = ocfs2_create_symlink_data(osb, handle, inode,
1632 symname);
1633 if (status < 0) {
1634 mlog_errno(status);
1635 goto bail;
1636 }
1637 }
1638
1639 status = ocfs2_add_entry(handle, dentry, inode,
1640 le64_to_cpu(fe->i_blkno), parent_fe_bh,
1641 de_bh);
1642 if (status < 0) {
1643 mlog_errno(status);
1644 goto bail;
1645 }
1646
Mark Fasheh0027dd52006-09-21 16:51:28 -07001647 status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
Mark Fasheh379dfe92006-09-08 14:21:03 -07001648 if (status) {
1649 mlog_errno(status);
1650 goto bail;
1651 }
1652
Mark Fashehccd979b2005-12-15 14:31:24 -08001653 insert_inode_hash(inode);
1654 dentry->d_op = &ocfs2_dentry_ops;
1655 d_instantiate(dentry, inode);
1656bail:
1657 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001658 ocfs2_commit_trans(osb, handle);
Mark Fasheh6d8fc402006-10-06 11:54:33 -07001659
Mark Fashehe63aecb62007-10-18 15:30:42 -07001660 ocfs2_inode_unlock(dir, 1);
Mark Fasheh6d8fc402006-10-06 11:54:33 -07001661
Mark Fashehccd979b2005-12-15 14:31:24 -08001662 if (new_fe_bh)
1663 brelse(new_fe_bh);
1664 if (parent_fe_bh)
1665 brelse(parent_fe_bh);
1666 if (de_bh)
1667 brelse(de_bh);
1668 if (inode_ac)
1669 ocfs2_free_alloc_context(inode_ac);
1670 if (data_ac)
1671 ocfs2_free_alloc_context(data_ac);
1672 if ((status < 0) && inode)
1673 iput(inode);
1674
1675 mlog_exit(status);
1676
1677 return status;
1678}
1679
Mark Fashehccd979b2005-12-15 14:31:24 -08001680static int ocfs2_blkno_stringify(u64 blkno, char *name)
1681{
1682 int status, namelen;
1683
1684 mlog_entry_void();
1685
Mark Fashehb06970532006-03-03 10:24:33 -08001686 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
1687 (long long)blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -08001688 if (namelen <= 0) {
1689 if (namelen)
1690 status = namelen;
1691 else
1692 status = -EINVAL;
1693 mlog_errno(status);
1694 goto bail;
1695 }
1696 if (namelen != OCFS2_ORPHAN_NAMELEN) {
1697 status = -EINVAL;
1698 mlog_errno(status);
1699 goto bail;
1700 }
1701
1702 mlog(0, "built filename '%s' for orphan dir (len=%d)\n", name,
1703 namelen);
1704
1705 status = 0;
1706bail:
1707 mlog_exit(status);
1708 return status;
1709}
1710
1711static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
Mark Fasheh5098c272006-10-05 18:12:57 -07001712 struct inode **ret_orphan_dir,
Mark Fashehccd979b2005-12-15 14:31:24 -08001713 struct inode *inode,
1714 char *name,
1715 struct buffer_head **de_bh)
1716{
Mark Fasheh5098c272006-10-05 18:12:57 -07001717 struct inode *orphan_dir_inode;
Mark Fashehccd979b2005-12-15 14:31:24 -08001718 struct buffer_head *orphan_dir_bh = NULL;
1719 int status = 0;
1720
1721 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
1722 if (status < 0) {
1723 mlog_errno(status);
Mark Fasheh5098c272006-10-05 18:12:57 -07001724 return status;
Mark Fashehccd979b2005-12-15 14:31:24 -08001725 }
1726
1727 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
1728 ORPHAN_DIR_SYSTEM_INODE,
1729 osb->slot_num);
1730 if (!orphan_dir_inode) {
1731 status = -ENOENT;
1732 mlog_errno(status);
Mark Fasheh5098c272006-10-05 18:12:57 -07001733 return status;
Mark Fashehccd979b2005-12-15 14:31:24 -08001734 }
1735
Mark Fasheh5098c272006-10-05 18:12:57 -07001736 mutex_lock(&orphan_dir_inode->i_mutex);
1737
Mark Fashehe63aecb62007-10-18 15:30:42 -07001738 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001739 if (status < 0) {
1740 mlog_errno(status);
1741 goto leave;
1742 }
1743
1744 status = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
1745 orphan_dir_bh, name,
1746 OCFS2_ORPHAN_NAMELEN, de_bh);
1747 if (status < 0) {
Mark Fashehe63aecb62007-10-18 15:30:42 -07001748 ocfs2_inode_unlock(orphan_dir_inode, 1);
Mark Fasheh5098c272006-10-05 18:12:57 -07001749
Mark Fashehccd979b2005-12-15 14:31:24 -08001750 mlog_errno(status);
1751 goto leave;
1752 }
1753
Mark Fasheh5098c272006-10-05 18:12:57 -07001754 *ret_orphan_dir = orphan_dir_inode;
1755
Mark Fashehccd979b2005-12-15 14:31:24 -08001756leave:
Mark Fasheh5098c272006-10-05 18:12:57 -07001757 if (status) {
1758 mutex_unlock(&orphan_dir_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -08001759 iput(orphan_dir_inode);
Mark Fasheh5098c272006-10-05 18:12:57 -07001760 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001761
1762 if (orphan_dir_bh)
1763 brelse(orphan_dir_bh);
1764
1765 mlog_exit(status);
1766 return status;
1767}
1768
1769static int ocfs2_orphan_add(struct ocfs2_super *osb,
Mark Fasheh1fabe142006-10-09 18:11:45 -07001770 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -08001771 struct inode *inode,
1772 struct ocfs2_dinode *fe,
1773 char *name,
Mark Fasheh5098c272006-10-05 18:12:57 -07001774 struct buffer_head *de_bh,
1775 struct inode *orphan_dir_inode)
Mark Fashehccd979b2005-12-15 14:31:24 -08001776{
Mark Fashehccd979b2005-12-15 14:31:24 -08001777 struct buffer_head *orphan_dir_bh = NULL;
1778 int status = 0;
1779 struct ocfs2_dinode *orphan_fe;
1780
1781 mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
1782
Mark Fashehccd979b2005-12-15 14:31:24 -08001783 status = ocfs2_read_block(osb,
1784 OCFS2_I(orphan_dir_inode)->ip_blkno,
1785 &orphan_dir_bh, OCFS2_BH_CACHED,
1786 orphan_dir_inode);
1787 if (status < 0) {
1788 mlog_errno(status);
1789 goto leave;
1790 }
1791
1792 status = ocfs2_journal_access(handle, orphan_dir_inode, orphan_dir_bh,
1793 OCFS2_JOURNAL_ACCESS_WRITE);
1794 if (status < 0) {
1795 mlog_errno(status);
1796 goto leave;
1797 }
1798
1799 /* we're a cluster, and nlink can change on disk from
1800 * underneath us... */
1801 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
1802 if (S_ISDIR(inode->i_mode))
1803 le16_add_cpu(&orphan_fe->i_links_count, 1);
1804 orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
1805
1806 status = ocfs2_journal_dirty(handle, orphan_dir_bh);
1807 if (status < 0) {
1808 mlog_errno(status);
1809 goto leave;
1810 }
1811
1812 status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
1813 OCFS2_ORPHAN_NAMELEN, inode,
1814 OCFS2_I(inode)->ip_blkno,
1815 orphan_dir_bh, de_bh);
1816 if (status < 0) {
1817 mlog_errno(status);
1818 goto leave;
1819 }
1820
1821 le32_add_cpu(&fe->i_flags, OCFS2_ORPHANED_FL);
1822
1823 /* Record which orphan dir our inode now resides
1824 * in. delete_inode will use this to determine which orphan
1825 * dir to lock. */
Tiger Yang50008632007-03-20 16:01:38 -07001826 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
Mark Fashehccd979b2005-12-15 14:31:24 -08001827
Mark Fashehb06970532006-03-03 10:24:33 -08001828 mlog(0, "Inode %llu orphaned in slot %d\n",
1829 (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
Mark Fashehccd979b2005-12-15 14:31:24 -08001830
1831leave:
Mark Fashehccd979b2005-12-15 14:31:24 -08001832 if (orphan_dir_bh)
1833 brelse(orphan_dir_bh);
1834
1835 mlog_exit(status);
1836 return status;
1837}
1838
1839/* unlike orphan_add, we expect the orphan dir to already be locked here. */
1840int ocfs2_orphan_del(struct ocfs2_super *osb,
Mark Fasheh1fabe142006-10-09 18:11:45 -07001841 handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -08001842 struct inode *orphan_dir_inode,
1843 struct inode *inode,
1844 struct buffer_head *orphan_dir_bh)
1845{
1846 char name[OCFS2_ORPHAN_NAMELEN + 1];
1847 struct ocfs2_dinode *orphan_fe;
1848 int status = 0;
1849 struct buffer_head *target_de_bh = NULL;
1850 struct ocfs2_dir_entry *target_de = NULL;
1851
1852 mlog_entry_void();
1853
1854 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
1855 if (status < 0) {
1856 mlog_errno(status);
1857 goto leave;
1858 }
1859
Mark Fashehb06970532006-03-03 10:24:33 -08001860 mlog(0, "removing '%s' from orphan dir %llu (namelen=%d)\n",
1861 name, (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
1862 OCFS2_ORPHAN_NAMELEN);
Mark Fashehccd979b2005-12-15 14:31:24 -08001863
1864 /* find it's spot in the orphan directory */
1865 target_de_bh = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN,
1866 orphan_dir_inode, &target_de);
1867 if (!target_de_bh) {
1868 status = -ENOENT;
1869 mlog_errno(status);
1870 goto leave;
1871 }
1872
1873 /* remove it from the orphan directory */
1874 status = ocfs2_delete_entry(handle, orphan_dir_inode, target_de,
1875 target_de_bh);
1876 if (status < 0) {
1877 mlog_errno(status);
1878 goto leave;
1879 }
1880
1881 status = ocfs2_journal_access(handle,orphan_dir_inode, orphan_dir_bh,
1882 OCFS2_JOURNAL_ACCESS_WRITE);
1883 if (status < 0) {
1884 mlog_errno(status);
1885 goto leave;
1886 }
1887
1888 /* do the i_nlink dance! :) */
1889 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
1890 if (S_ISDIR(inode->i_mode))
1891 le16_add_cpu(&orphan_fe->i_links_count, -1);
1892 orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
1893
1894 status = ocfs2_journal_dirty(handle, orphan_dir_bh);
1895 if (status < 0) {
1896 mlog_errno(status);
1897 goto leave;
1898 }
1899
1900leave:
1901 if (target_de_bh)
1902 brelse(target_de_bh);
1903
1904 mlog_exit(status);
1905 return status;
1906}
1907
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08001908const struct inode_operations ocfs2_dir_iops = {
Mark Fashehccd979b2005-12-15 14:31:24 -08001909 .create = ocfs2_create,
1910 .lookup = ocfs2_lookup,
1911 .link = ocfs2_link,
1912 .unlink = ocfs2_unlink,
1913 .rmdir = ocfs2_unlink,
1914 .symlink = ocfs2_symlink,
1915 .mkdir = ocfs2_mkdir,
1916 .mknod = ocfs2_mknod,
1917 .rename = ocfs2_rename,
1918 .setattr = ocfs2_setattr,
1919 .getattr = ocfs2_getattr,
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001920 .permission = ocfs2_permission,
Mark Fashehccd979b2005-12-15 14:31:24 -08001921};