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