?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ocfs2: add ocfs2_init_acl in mknod
[linux-2.6/btrfs-unstable.git] / fs / ocfs2 / namei.c
blob765514512096af377c3b36fce711d1acdb97e483
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
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"
59 #include "super.h"
60 #include "symlink.h"
61 #include "sysfile.h"
62 #include "uptodate.h"
63 #include "xattr.h"
64 #include "acl.h"
65
66 #include "buffer_head_io.h"
67
68 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
69 struct inode *dir,
70 struct inode *inode,
71 struct dentry *dentry,
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 struct inode *inode,
81 char *name,
82 struct buffer_head **de_bh);
83
84 static int ocfs2_orphan_add(struct ocfs2_super *osb,
85 handle_t *handle,
86 struct inode *inode,
87 struct ocfs2_dinode *fe,
88 char *name,
89 struct buffer_head *de_bh,
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(dir, NULL, 0);
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->i_uid = current_fsuid();
208 if (dir->i_mode & S_ISGID) {
209 inode->i_gid = dir->i_gid;
210 if (S_ISDIR(mode))
211 mode |= S_ISGID;
212 } else
213 inode->i_gid = current_fsgid();
214 inode->i_mode = mode;
215 return inode;
216 }
217
218 static int ocfs2_mknod(struct inode *dir,
219 struct dentry *dentry,
220 int mode,
221 dev_t dev)
222 {
223 int status = 0;
224 struct buffer_head *parent_fe_bh = NULL;
225 handle_t *handle = NULL;
226 struct ocfs2_super *osb;
227 struct ocfs2_dinode *dirfe;
228 struct buffer_head *new_fe_bh = NULL;
229 struct buffer_head *de_bh = NULL;
230 struct inode *inode = NULL;
231 struct ocfs2_alloc_context *inode_ac = NULL;
232 struct ocfs2_alloc_context *data_ac = NULL;
233 struct ocfs2_alloc_context *xattr_ac = NULL;
234 int want_clusters = 0;
235 int xattr_credits = 0;
236 struct ocfs2_security_xattr_info si = {
237 .enable = 1,
238 };
239
240 mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
241 (unsigned long)dev, dentry->d_name.len,
242 dentry->d_name.name);
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)) {
255 status = -EMLINK;
256 goto leave;
257 }
258
259 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
260 if (!dirfe->i_links_count) {
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, &de_bh);
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, &xattr_ac);
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 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
320 if (status < 0) {
321 if (status != -ENOSPC)
322 mlog_errno(status);
323 goto leave;
324 }
325
326 handle = ocfs2_start_trans(osb, OCFS2_MKNOD_CREDITS + xattr_credits);
327 if (IS_ERR(handle)) {
328 status = PTR_ERR(handle);
329 handle = NULL;
330 mlog_errno(status);
331 goto leave;
332 }
333
334 /* do the real work now. */
335 status = ocfs2_mknod_locked(osb, dir, inode, dentry, dev,
336 &new_fe_bh, parent_fe_bh, handle,
337 inode_ac);
338 if (status < 0) {
339 mlog_errno(status);
340 goto leave;
341 }
342
343 if (S_ISDIR(mode)) {
344 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
345 new_fe_bh, data_ac);
346 if (status < 0) {
347 mlog_errno(status);
348 goto leave;
349 }
350
351 status = ocfs2_journal_access(handle, dir, parent_fe_bh,
352 OCFS2_JOURNAL_ACCESS_WRITE);
353 if (status < 0) {
354 mlog_errno(status);
355 goto leave;
356 }
357 le16_add_cpu(&dirfe->i_links_count, 1);
358 status = ocfs2_journal_dirty(handle, parent_fe_bh);
359 if (status < 0) {
360 mlog_errno(status);
361 goto leave;
362 }
363 inc_nlink(dir);
364 }
365
366 status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh,
367 xattr_ac, data_ac);
368 if (status < 0) {
369 mlog_errno(status);
370 goto leave;
371 }
372
373 if (si.enable) {
374 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
375 xattr_ac, data_ac);
376 if (status < 0) {
377 mlog_errno(status);
378 goto leave;
379 }
380 }
381
382 status = ocfs2_add_entry(handle, dentry, inode,
383 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
384 de_bh);
385 if (status < 0) {
386 mlog_errno(status);
387 goto leave;
388 }
389
390 status = ocfs2_dentry_attach_lock(dentry, inode,
391 OCFS2_I(dir)->ip_blkno);
392 if (status) {
393 mlog_errno(status);
394 goto leave;
395 }
396
397 insert_inode_hash(inode);
398 dentry->d_op = &ocfs2_dentry_ops;
399 d_instantiate(dentry, inode);
400 status = 0;
401 leave:
402 if (handle)
403 ocfs2_commit_trans(osb, handle);
404
405 ocfs2_inode_unlock(dir, 1);
406
407 if (status == -ENOSPC)
408 mlog(0, "Disk is full\n");
409
410 brelse(new_fe_bh);
411 brelse(de_bh);
412 brelse(parent_fe_bh);
413 kfree(si.name);
414 kfree(si.value);
415
416 if ((status < 0) && inode) {
417 clear_nlink(inode);
418 iput(inode);
419 }
420
421 if (inode_ac)
422 ocfs2_free_alloc_context(inode_ac);
423
424 if (data_ac)
425 ocfs2_free_alloc_context(data_ac);
426
427 if (xattr_ac)
428 ocfs2_free_alloc_context(xattr_ac);
429
430 mlog_exit(status);
431
432 return status;
433 }
434
435 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
436 struct inode *dir,
437 struct inode *inode,
438 struct dentry *dentry,
439 dev_t dev,
440 struct buffer_head **new_fe_bh,
441 struct buffer_head *parent_fe_bh,
442 handle_t *handle,
443 struct ocfs2_alloc_context *inode_ac)
444 {
445 int status = 0;
446 struct ocfs2_dinode *fe = NULL;
447 struct ocfs2_extent_list *fel;
448 u64 fe_blkno = 0;
449 u16 suballoc_bit;
450
451 mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry,
452 inode->i_mode, (unsigned long)dev, dentry->d_name.len,
453 dentry->d_name.name);
454
455 *new_fe_bh = NULL;
456
457 status = ocfs2_claim_new_inode(osb, handle, inode_ac, &suballoc_bit,
458 &fe_blkno);
459 if (status < 0) {
460 mlog_errno(status);
461 goto leave;
462 }
463
464 /* populate as many fields early on as possible - many of
465 * these are used by the support functions here and in
466 * callers. */
467 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
468 OCFS2_I(inode)->ip_blkno = fe_blkno;
469 spin_lock(&osb->osb_lock);
470 inode->i_generation = osb->s_next_generation++;
471 spin_unlock(&osb->osb_lock);
472
473 *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
474 if (!*new_fe_bh) {
475 status = -EIO;
476 mlog_errno(status);
477 goto leave;
478 }
479 ocfs2_set_new_buffer_uptodate(inode, *new_fe_bh);
480
481 status = ocfs2_journal_access(handle, inode, *new_fe_bh,
482 OCFS2_JOURNAL_ACCESS_CREATE);
483 if (status < 0) {
484 mlog_errno(status);
485 goto leave;
486 }
487
488 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
489 memset(fe, 0, osb->sb->s_blocksize);
490
491 fe->i_generation = cpu_to_le32(inode->i_generation);
492 fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
493 fe->i_blkno = cpu_to_le64(fe_blkno);
494 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
495 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
496 fe->i_uid = cpu_to_le32(inode->i_uid);
497 fe->i_gid = cpu_to_le32(inode->i_gid);
498 fe->i_mode = cpu_to_le16(inode->i_mode);
499 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
500 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
501 fe->i_links_count = cpu_to_le16(inode->i_nlink);
502
503 fe->i_last_eb_blk = 0;
504 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
505 le32_add_cpu(&fe->i_flags, OCFS2_VALID_FL);
506 fe->i_atime = fe->i_ctime = fe->i_mtime =
507 cpu_to_le64(CURRENT_TIME.tv_sec);
508 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
509 cpu_to_le32(CURRENT_TIME.tv_nsec);
510 fe->i_dtime = 0;
511
512 /*
513 * If supported, directories start with inline data.
514 */
515 if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
516 u16 feat = le16_to_cpu(fe->i_dyn_features);
517
518 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
519
520 fe->id2.i_data.id_count = cpu_to_le16(ocfs2_max_inline_data(osb->sb));
521 } else {
522 fel = &fe->id2.i_list;
523 fel->l_tree_depth = 0;
524 fel->l_next_free_rec = 0;
525 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
526 }
527
528 status = ocfs2_journal_dirty(handle, *new_fe_bh);
529 if (status < 0) {
530 mlog_errno(status);
531 goto leave;
532 }
533
534 if (ocfs2_populate_inode(inode, fe, 1) < 0) {
535 mlog(ML_ERROR, "populate inode failed! bh->b_blocknr=%llu, "
536 "i_blkno=%llu, i_ino=%lu\n",
537 (unsigned long long)(*new_fe_bh)->b_blocknr,
538 (unsigned long long)le64_to_cpu(fe->i_blkno),
539 inode->i_ino);
540 BUG();
541 }
542
543 ocfs2_inode_set_new(osb, inode);
544 if (!ocfs2_mount_local(osb)) {
545 status = ocfs2_create_new_inode_locks(inode);
546 if (status < 0)
547 mlog_errno(status);
548 }
549
550 status = 0; /* error in ocfs2_create_new_inode_locks is not
551 * critical */
552
553 leave:
554 if (status < 0) {
555 if (*new_fe_bh) {
556 brelse(*new_fe_bh);
557 *new_fe_bh = NULL;
558 }
559 }
560
561 mlog_exit(status);
562 return status;
563 }
564
565 static int ocfs2_mkdir(struct inode *dir,
566 struct dentry *dentry,
567 int mode)
568 {
569 int ret;
570
571 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
572 dentry->d_name.len, dentry->d_name.name);
573 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
574 mlog_exit(ret);
575
576 return ret;
577 }
578
579 static int ocfs2_create(struct inode *dir,
580 struct dentry *dentry,
581 int mode,
582 struct nameidata *nd)
583 {
584 int ret;
585
586 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
587 dentry->d_name.len, dentry->d_name.name);
588 ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
589 mlog_exit(ret);
590
591 return ret;
592 }
593
594 static int ocfs2_link(struct dentry *old_dentry,
595 struct inode *dir,
596 struct dentry *dentry)
597 {
598 handle_t *handle;
599 struct inode *inode = old_dentry->d_inode;
600 int err;
601 struct buffer_head *fe_bh = NULL;
602 struct buffer_head *parent_fe_bh = NULL;
603 struct buffer_head *de_bh = NULL;
604 struct ocfs2_dinode *fe = NULL;
605 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
606
607 mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode->i_ino,
608 old_dentry->d_name.len, old_dentry->d_name.name,
609 dentry->d_name.len, dentry->d_name.name);
610
611 if (S_ISDIR(inode->i_mode))
612 return -EPERM;
613
614 err = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
615 if (err < 0) {
616 if (err != -ENOENT)
617 mlog_errno(err);
618 return err;
619 }
620
621 if (!dir->i_nlink) {
622 err = -ENOENT;
623 goto out;
624 }
625
626 err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
627 dentry->d_name.len);
628 if (err)
629 goto out;
630
631 err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
632 dentry->d_name.name,
633 dentry->d_name.len, &de_bh);
634 if (err < 0) {
635 mlog_errno(err);
636 goto out;
637 }
638
639 err = ocfs2_inode_lock(inode, &fe_bh, 1);
640 if (err < 0) {
641 if (err != -ENOENT)
642 mlog_errno(err);
643 goto out;
644 }
645
646 fe = (struct ocfs2_dinode *) fe_bh->b_data;
647 if (le16_to_cpu(fe->i_links_count) >= OCFS2_LINK_MAX) {
648 err = -EMLINK;
649 goto out_unlock_inode;
650 }
651
652 handle = ocfs2_start_trans(osb, OCFS2_LINK_CREDITS);
653 if (IS_ERR(handle)) {
654 err = PTR_ERR(handle);
655 handle = NULL;
656 mlog_errno(err);
657 goto out_unlock_inode;
658 }
659
660 err = ocfs2_journal_access(handle, inode, fe_bh,
661 OCFS2_JOURNAL_ACCESS_WRITE);
662 if (err < 0) {
663 mlog_errno(err);
664 goto out_commit;
665 }
666
667 inc_nlink(inode);
668 inode->i_ctime = CURRENT_TIME;
669 fe->i_links_count = cpu_to_le16(inode->i_nlink);
670 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
671 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
672
673 err = ocfs2_journal_dirty(handle, fe_bh);
674 if (err < 0) {
675 le16_add_cpu(&fe->i_links_count, -1);
676 drop_nlink(inode);
677 mlog_errno(err);
678 goto out_commit;
679 }
680
681 err = ocfs2_add_entry(handle, dentry, inode,
682 OCFS2_I(inode)->ip_blkno,
683 parent_fe_bh, de_bh);
684 if (err) {
685 le16_add_cpu(&fe->i_links_count, -1);
686 drop_nlink(inode);
687 mlog_errno(err);
688 goto out_commit;
689 }
690
691 err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
692 if (err) {
693 mlog_errno(err);
694 goto out_commit;
695 }
696
697 atomic_inc(&inode->i_count);
698 dentry->d_op = &ocfs2_dentry_ops;
699 d_instantiate(dentry, inode);
700
701 out_commit:
702 ocfs2_commit_trans(osb, handle);
703 out_unlock_inode:
704 ocfs2_inode_unlock(inode, 1);
705
706 out:
707 ocfs2_inode_unlock(dir, 1);
708
709 brelse(de_bh);
710 brelse(fe_bh);
711 brelse(parent_fe_bh);
712
713 mlog_exit(err);
714
715 return err;
716 }
717
718 /*
719 * Takes and drops an exclusive lock on the given dentry. This will
720 * force other nodes to drop it.
721 */
722 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
723 {
724 int ret;
725
726 ret = ocfs2_dentry_lock(dentry, 1);
727 if (ret)
728 mlog_errno(ret);
729 else
730 ocfs2_dentry_unlock(dentry, 1);
731
732 return ret;
733 }
734
735 static inline int inode_is_unlinkable(struct inode *inode)
736 {
737 if (S_ISDIR(inode->i_mode)) {
738 if (inode->i_nlink == 2)
739 return 1;
740 return 0;
741 }
742
743 if (inode->i_nlink == 1)
744 return 1;
745 return 0;
746 }
747
748 static int ocfs2_unlink(struct inode *dir,
749 struct dentry *dentry)
750 {
751 int status;
752 int child_locked = 0;
753 struct inode *inode = dentry->d_inode;
754 struct inode *orphan_dir = NULL;
755 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
756 u64 blkno;
757 struct ocfs2_dinode *fe = NULL;
758 struct buffer_head *fe_bh = NULL;
759 struct buffer_head *parent_node_bh = NULL;
760 handle_t *handle = NULL;
761 struct ocfs2_dir_entry *dirent = NULL;
762 struct buffer_head *dirent_bh = NULL;
763 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
764 struct buffer_head *orphan_entry_bh = NULL;
765
766 mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
767 dentry->d_name.len, dentry->d_name.name);
768
769 BUG_ON(dentry->d_parent->d_inode != dir);
770
771 mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
772
773 if (inode == osb->root_inode) {
774 mlog(0, "Cannot delete the root directory\n");
775 return -EPERM;
776 }
777
778 status = ocfs2_inode_lock(dir, &parent_node_bh, 1);
779 if (status < 0) {
780 if (status != -ENOENT)
781 mlog_errno(status);
782 return status;
783 }
784
785 status = ocfs2_find_files_on_disk(dentry->d_name.name,
786 dentry->d_name.len, &blkno,
787 dir, &dirent_bh, &dirent);
788 if (status < 0) {
789 if (status != -ENOENT)
790 mlog_errno(status);
791 goto leave;
792 }
793
794 if (OCFS2_I(inode)->ip_blkno != blkno) {
795 status = -ENOENT;
796
797 mlog(0, "ip_blkno %llu != dirent blkno %llu ip_flags = %x\n",
798 (unsigned long long)OCFS2_I(inode)->ip_blkno,
799 (unsigned long long)blkno, OCFS2_I(inode)->ip_flags);
800 goto leave;
801 }
802
803 status = ocfs2_inode_lock(inode, &fe_bh, 1);
804 if (status < 0) {
805 if (status != -ENOENT)
806 mlog_errno(status);
807 goto leave;
808 }
809 child_locked = 1;
810
811 if (S_ISDIR(inode->i_mode)) {
812 if (!ocfs2_empty_dir(inode)) {
813 status = -ENOTEMPTY;
814 goto leave;
815 } else if (inode->i_nlink != 2) {
816 status = -ENOTEMPTY;
817 goto leave;
818 }
819 }
820
821 status = ocfs2_remote_dentry_delete(dentry);
822 if (status < 0) {
823 /* This remote delete should succeed under all normal
824 * circumstances. */
825 mlog_errno(status);
826 goto leave;
827 }
828
829 if (inode_is_unlinkable(inode)) {
830 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, inode,
831 orphan_name,
832 &orphan_entry_bh);
833 if (status < 0) {
834 mlog_errno(status);
835 goto leave;
836 }
837 }
838
839 handle = ocfs2_start_trans(osb, OCFS2_UNLINK_CREDITS);
840 if (IS_ERR(handle)) {
841 status = PTR_ERR(handle);
842 handle = NULL;
843 mlog_errno(status);
844 goto leave;
845 }
846
847 status = ocfs2_journal_access(handle, inode, fe_bh,
848 OCFS2_JOURNAL_ACCESS_WRITE);
849 if (status < 0) {
850 mlog_errno(status);
851 goto leave;
852 }
853
854 fe = (struct ocfs2_dinode *) fe_bh->b_data;
855
856 if (inode_is_unlinkable(inode)) {
857 status = ocfs2_orphan_add(osb, handle, inode, fe, orphan_name,
858 orphan_entry_bh, orphan_dir);
859 if (status < 0) {
860 mlog_errno(status);
861 goto leave;
862 }
863 }
864
865 /* delete the name from the parent dir */
866 status = ocfs2_delete_entry(handle, dir, dirent, dirent_bh);
867 if (status < 0) {
868 mlog_errno(status);
869 goto leave;
870 }
871
872 if (S_ISDIR(inode->i_mode))
873 drop_nlink(inode);
874 drop_nlink(inode);
875 fe->i_links_count = cpu_to_le16(inode->i_nlink);
876
877 status = ocfs2_journal_dirty(handle, fe_bh);
878 if (status < 0) {
879 mlog_errno(status);
880 goto leave;
881 }
882
883 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
884 if (S_ISDIR(inode->i_mode))
885 drop_nlink(dir);
886
887 status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
888 if (status < 0) {
889 mlog_errno(status);
890 if (S_ISDIR(inode->i_mode))
891 inc_nlink(dir);
892 }
893
894 leave:
895 if (handle)
896 ocfs2_commit_trans(osb, handle);
897
898 if (child_locked)
899 ocfs2_inode_unlock(inode, 1);
900
901 ocfs2_inode_unlock(dir, 1);
902
903 if (orphan_dir) {
904 /* This was locked for us in ocfs2_prepare_orphan_dir() */
905 ocfs2_inode_unlock(orphan_dir, 1);
906 mutex_unlock(&orphan_dir->i_mutex);
907 iput(orphan_dir);
908 }
909
910 brelse(fe_bh);
911 brelse(dirent_bh);
912 brelse(parent_node_bh);
913 brelse(orphan_entry_bh);
914
915 mlog_exit(status);
916
917 return status;
918 }
919
920 /*
921 * The only place this should be used is rename!
922 * if they have the same id, then the 1st one is the only one locked.
923 */
924 static int ocfs2_double_lock(struct ocfs2_super *osb,
925 struct buffer_head **bh1,
926 struct inode *inode1,
927 struct buffer_head **bh2,
928 struct inode *inode2)
929 {
930 int status;
931 struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
932 struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
933 struct buffer_head **tmpbh;
934 struct inode *tmpinode;
935
936 mlog_entry("(inode1 = %llu, inode2 = %llu)\n",
937 (unsigned long long)oi1->ip_blkno,
938 (unsigned long long)oi2->ip_blkno);
939
940 if (*bh1)
941 *bh1 = NULL;
942 if (*bh2)
943 *bh2 = NULL;
944
945 /* we always want to lock the one with the lower lockid first. */
946 if (oi1->ip_blkno != oi2->ip_blkno) {
947 if (oi1->ip_blkno < oi2->ip_blkno) {
948 /* switch id1 and id2 around */
949 mlog(0, "switching them around...\n");
950 tmpbh = bh2;
951 bh2 = bh1;
952 bh1 = tmpbh;
953
954 tmpinode = inode2;
955 inode2 = inode1;
956 inode1 = tmpinode;
957 }
958 /* lock id2 */
959 status = ocfs2_inode_lock(inode2, bh2, 1);
960 if (status < 0) {
961 if (status != -ENOENT)
962 mlog_errno(status);
963 goto bail;
964 }
965 }
966
967 /* lock id1 */
968 status = ocfs2_inode_lock(inode1, bh1, 1);
969 if (status < 0) {
970 /*
971 * An error return must mean that no cluster locks
972 * were held on function exit.
973 */
974 if (oi1->ip_blkno != oi2->ip_blkno)
975 ocfs2_inode_unlock(inode2, 1);
976
977 if (status != -ENOENT)
978 mlog_errno(status);
979 }
980
981 bail:
982 mlog_exit(status);
983 return status;
984 }
985
986 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
987 {
988 ocfs2_inode_unlock(inode1, 1);
989
990 if (inode1 != inode2)
991 ocfs2_inode_unlock(inode2, 1);
992 }
993
994 static int ocfs2_rename(struct inode *old_dir,
995 struct dentry *old_dentry,
996 struct inode *new_dir,
997 struct dentry *new_dentry)
998 {
999 int status = 0, rename_lock = 0, parents_locked = 0;
1000 int old_child_locked = 0, new_child_locked = 0;
1001 struct inode *old_inode = old_dentry->d_inode;
1002 struct inode *new_inode = new_dentry->d_inode;
1003 struct inode *orphan_dir = NULL;
1004 struct ocfs2_dinode *newfe = NULL;
1005 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
1006 struct buffer_head *orphan_entry_bh = NULL;
1007 struct buffer_head *newfe_bh = NULL;
1008 struct buffer_head *old_inode_bh = NULL;
1009 struct buffer_head *insert_entry_bh = NULL;
1010 struct ocfs2_super *osb = NULL;
1011 u64 newfe_blkno, old_de_ino;
1012 handle_t *handle = NULL;
1013 struct buffer_head *old_dir_bh = NULL;
1014 struct buffer_head *new_dir_bh = NULL;
1015 struct ocfs2_dir_entry *old_inode_dot_dot_de = NULL, *old_de = NULL,
1016 *new_de = NULL;
1017 struct buffer_head *new_de_bh = NULL, *old_de_bh = NULL; // bhs for above
1018 struct buffer_head *old_inode_de_bh = NULL; // if old_dentry is a dir,
1019 // this is the 1st dirent bh
1020 nlink_t old_dir_nlink = old_dir->i_nlink;
1021 struct ocfs2_dinode *old_di;
1022
1023 /* At some point it might be nice to break this function up a
1024 * bit. */
1025
1026 mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p, from='%.*s' to='%.*s')\n",
1027 old_dir, old_dentry, new_dir, new_dentry,
1028 old_dentry->d_name.len, old_dentry->d_name.name,
1029 new_dentry->d_name.len, new_dentry->d_name.name);
1030
1031 osb = OCFS2_SB(old_dir->i_sb);
1032
1033 if (new_inode) {
1034 if (!igrab(new_inode))
1035 BUG();
1036 }
1037
1038 /* Assume a directory hierarchy thusly:
1039 * a/b/c
1040 * a/d
1041 * a,b,c, and d are all directories.
1042 *
1043 * from cwd of 'a' on both nodes:
1044 * node1: mv b/c d
1045 * node2: mv d b/c
1046 *
1047 * And that's why, just like the VFS, we need a file system
1048 * rename lock. */
1049 if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1050 status = ocfs2_rename_lock(osb);
1051 if (status < 0) {
1052 mlog_errno(status);
1053 goto bail;
1054 }
1055 rename_lock = 1;
1056 }
1057
1058 /* if old and new are the same, this'll just do one lock. */
1059 status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1060 &new_dir_bh, new_dir);
1061 if (status < 0) {
1062 mlog_errno(status);
1063 goto bail;
1064 }
1065 parents_locked = 1;
1066
1067 /* make sure both dirs have bhs
1068 * get an extra ref on old_dir_bh if old==new */
1069 if (!new_dir_bh) {
1070 if (old_dir_bh) {
1071 new_dir_bh = old_dir_bh;
1072 get_bh(new_dir_bh);
1073 } else {
1074 mlog(ML_ERROR, "no old_dir_bh!\n");
1075 status = -EIO;
1076 goto bail;
1077 }
1078 }
1079
1080 /*
1081 * Aside from allowing a meta data update, the locking here
1082 * also ensures that the downconvert thread on other nodes
1083 * won't have to concurrently downconvert the inode and the
1084 * dentry locks.
1085 */
1086 status = ocfs2_inode_lock(old_inode, &old_inode_bh, 1);
1087 if (status < 0) {
1088 if (status != -ENOENT)
1089 mlog_errno(status);
1090 goto bail;
1091 }
1092 old_child_locked = 1;
1093
1094 status = ocfs2_remote_dentry_delete(old_dentry);
1095 if (status < 0) {
1096 mlog_errno(status);
1097 goto bail;
1098 }
1099
1100 if (S_ISDIR(old_inode->i_mode)) {
1101 u64 old_inode_parent;
1102
1103 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1104 old_inode, &old_inode_de_bh,
1105 &old_inode_dot_dot_de);
1106 if (status) {
1107 status = -EIO;
1108 goto bail;
1109 }
1110
1111 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1112 status = -EIO;
1113 goto bail;
1114 }
1115
1116 if (!new_inode && new_dir != old_dir &&
1117 new_dir->i_nlink >= OCFS2_LINK_MAX) {
1118 status = -EMLINK;
1119 goto bail;
1120 }
1121 }
1122
1123 status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1124 old_dentry->d_name.len,
1125 &old_de_ino);
1126 if (status) {
1127 status = -ENOENT;
1128 goto bail;
1129 }
1130
1131 /*
1132 * Check for inode number is _not_ due to possible IO errors.
1133 * We might rmdir the source, keep it as pwd of some process
1134 * and merrily kill the link to whatever was created under the
1135 * same name. Goodbye sticky bit ;-<
1136 */
1137 if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1138 status = -ENOENT;
1139 goto bail;
1140 }
1141
1142 /* check if the target already exists (in which case we need
1143 * to delete it */
1144 status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1145 new_dentry->d_name.len,
1146 &newfe_blkno, new_dir, &new_de_bh,
1147 &new_de);
1148 /* The only error we allow here is -ENOENT because the new
1149 * file not existing is perfectly valid. */
1150 if ((status < 0) && (status != -ENOENT)) {
1151 /* If we cannot find the file specified we should just */
1152 /* return the error... */
1153 mlog_errno(status);
1154 goto bail;
1155 }
1156
1157 if (!new_de && new_inode) {
1158 /*
1159 * Target was unlinked by another node while we were
1160 * waiting to get to ocfs2_rename(). There isn't
1161 * anything we can do here to help the situation, so
1162 * bubble up the appropriate error.
1163 */
1164 status = -ENOENT;
1165 goto bail;
1166 }
1167
1168 /* In case we need to overwrite an existing file, we blow it
1169 * away first */
1170 if (new_de) {
1171 /* VFS didn't think there existed an inode here, but
1172 * someone else in the cluster must have raced our
1173 * rename to create one. Today we error cleanly, in
1174 * the future we should consider calling iget to build
1175 * a new struct inode for this entry. */
1176 if (!new_inode) {
1177 status = -EACCES;
1178
1179 mlog(0, "We found an inode for name %.*s but VFS "
1180 "didn't give us one.\n", new_dentry->d_name.len,
1181 new_dentry->d_name.name);
1182 goto bail;
1183 }
1184
1185 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1186 status = -EACCES;
1187
1188 mlog(0, "Inode %llu and dir %llu disagree. flags = %x\n",
1189 (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1190 (unsigned long long)newfe_blkno,
1191 OCFS2_I(new_inode)->ip_flags);
1192 goto bail;
1193 }
1194
1195 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1196 if (status < 0) {
1197 if (status != -ENOENT)
1198 mlog_errno(status);
1199 goto bail;
1200 }
1201 new_child_locked = 1;
1202
1203 status = ocfs2_remote_dentry_delete(new_dentry);
1204 if (status < 0) {
1205 mlog_errno(status);
1206 goto bail;
1207 }
1208
1209 newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1210
1211 mlog(0, "aha rename over existing... new_de=%p new_blkno=%llu "
1212 "newfebh=%p bhblocknr=%llu\n", new_de,
1213 (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1214 (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1215
1216 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1217 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1218 new_inode,
1219 orphan_name,
1220 &orphan_entry_bh);
1221 if (status < 0) {
1222 mlog_errno(status);
1223 goto bail;
1224 }
1225 }
1226 } else {
1227 BUG_ON(new_dentry->d_parent->d_inode != new_dir);
1228
1229 status = ocfs2_check_dir_for_entry(new_dir,
1230 new_dentry->d_name.name,
1231 new_dentry->d_name.len);
1232 if (status)
1233 goto bail;
1234
1235 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1236 new_dentry->d_name.name,
1237 new_dentry->d_name.len,
1238 &insert_entry_bh);
1239 if (status < 0) {
1240 mlog_errno(status);
1241 goto bail;
1242 }
1243 }
1244
1245 handle = ocfs2_start_trans(osb, OCFS2_RENAME_CREDITS);
1246 if (IS_ERR(handle)) {
1247 status = PTR_ERR(handle);
1248 handle = NULL;
1249 mlog_errno(status);
1250 goto bail;
1251 }
1252
1253 if (new_de) {
1254 if (S_ISDIR(new_inode->i_mode)) {
1255 if (!ocfs2_empty_dir(new_inode) ||
1256 new_inode->i_nlink != 2) {
1257 status = -ENOTEMPTY;
1258 goto bail;
1259 }
1260 }
1261 status = ocfs2_journal_access(handle, new_inode, newfe_bh,
1262 OCFS2_JOURNAL_ACCESS_WRITE);
1263 if (status < 0) {
1264 mlog_errno(status);
1265 goto bail;
1266 }
1267
1268 if (S_ISDIR(new_inode->i_mode) ||
1269 (newfe->i_links_count == cpu_to_le16(1))){
1270 status = ocfs2_orphan_add(osb, handle, new_inode,
1271 newfe, orphan_name,
1272 orphan_entry_bh, orphan_dir);
1273 if (status < 0) {
1274 mlog_errno(status);
1275 goto bail;
1276 }
1277 }
1278
1279 /* change the dirent to point to the correct inode */
1280 status = ocfs2_update_entry(new_dir, handle, new_de_bh,
1281 new_de, old_inode);
1282 if (status < 0) {
1283 mlog_errno(status);
1284 goto bail;
1285 }
1286 new_dir->i_version++;
1287
1288 if (S_ISDIR(new_inode->i_mode))
1289 newfe->i_links_count = 0;
1290 else
1291 le16_add_cpu(&newfe->i_links_count, -1);
1292
1293 status = ocfs2_journal_dirty(handle, newfe_bh);
1294 if (status < 0) {
1295 mlog_errno(status);
1296 goto bail;
1297 }
1298 } else {
1299 /* if the name was not found in new_dir, add it now */
1300 status = ocfs2_add_entry(handle, new_dentry, old_inode,
1301 OCFS2_I(old_inode)->ip_blkno,
1302 new_dir_bh, insert_entry_bh);
1303 }
1304
1305 old_inode->i_ctime = CURRENT_TIME;
1306 mark_inode_dirty(old_inode);
1307
1308 status = ocfs2_journal_access(handle, old_inode, old_inode_bh,
1309 OCFS2_JOURNAL_ACCESS_WRITE);
1310 if (status >= 0) {
1311 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1312
1313 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
1314 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1315
1316 status = ocfs2_journal_dirty(handle, old_inode_bh);
1317 if (status < 0)
1318 mlog_errno(status);
1319 } else
1320 mlog_errno(status);
1321
1322 /*
1323 * Now that the name has been added to new_dir, remove the old name.
1324 *
1325 * We don't keep any directory entry context around until now
1326 * because the insert might have changed the type of directory
1327 * we're dealing with.
1328 */
1329 old_de_bh = ocfs2_find_entry(old_dentry->d_name.name,
1330 old_dentry->d_name.len,
1331 old_dir, &old_de);
1332 if (!old_de_bh) {
1333 status = -EIO;
1334 goto bail;
1335 }
1336
1337 status = ocfs2_delete_entry(handle, old_dir, old_de, old_de_bh);
1338 if (status < 0) {
1339 mlog_errno(status);
1340 goto bail;
1341 }
1342
1343 if (new_inode) {
1344 new_inode->i_nlink--;
1345 new_inode->i_ctime = CURRENT_TIME;
1346 }
1347 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1348 if (old_inode_de_bh) {
1349 status = ocfs2_update_entry(old_inode, handle, old_inode_de_bh,
1350 old_inode_dot_dot_de, new_dir);
1351 old_dir->i_nlink--;
1352 if (new_inode) {
1353 new_inode->i_nlink--;
1354 } else {
1355 inc_nlink(new_dir);
1356 mark_inode_dirty(new_dir);
1357 }
1358 }
1359 mark_inode_dirty(old_dir);
1360 ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1361 if (new_inode) {
1362 mark_inode_dirty(new_inode);
1363 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1364 }
1365
1366 if (old_dir != new_dir) {
1367 /* Keep the same times on both directories.*/
1368 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1369
1370 /*
1371 * This will also pick up the i_nlink change from the
1372 * block above.
1373 */
1374 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1375 }
1376
1377 if (old_dir_nlink != old_dir->i_nlink) {
1378 if (!old_dir_bh) {
1379 mlog(ML_ERROR, "need to change nlink for old dir "
1380 "%llu from %d to %d but bh is NULL!\n",
1381 (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1382 (int)old_dir_nlink, old_dir->i_nlink);
1383 } else {
1384 struct ocfs2_dinode *fe;
1385 status = ocfs2_journal_access(handle, old_dir,
1386 old_dir_bh,
1387 OCFS2_JOURNAL_ACCESS_WRITE);
1388 fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1389 fe->i_links_count = cpu_to_le16(old_dir->i_nlink);
1390 status = ocfs2_journal_dirty(handle, old_dir_bh);
1391 }
1392 }
1393
1394 ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1395 status = 0;
1396 bail:
1397 if (rename_lock)
1398 ocfs2_rename_unlock(osb);
1399
1400 if (handle)
1401 ocfs2_commit_trans(osb, handle);
1402
1403 if (parents_locked)
1404 ocfs2_double_unlock(old_dir, new_dir);
1405
1406 if (old_child_locked)
1407 ocfs2_inode_unlock(old_inode, 1);
1408
1409 if (new_child_locked)
1410 ocfs2_inode_unlock(new_inode, 1);
1411
1412 if (orphan_dir) {
1413 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1414 ocfs2_inode_unlock(orphan_dir, 1);
1415 mutex_unlock(&orphan_dir->i_mutex);
1416 iput(orphan_dir);
1417 }
1418
1419 if (new_inode)
1420 sync_mapping_buffers(old_inode->i_mapping);
1421
1422 if (new_inode)
1423 iput(new_inode);
1424 brelse(newfe_bh);
1425 brelse(old_inode_bh);
1426 brelse(old_dir_bh);
1427 brelse(new_dir_bh);
1428 brelse(new_de_bh);
1429 brelse(old_de_bh);
1430 brelse(old_inode_de_bh);
1431 brelse(orphan_entry_bh);
1432 brelse(insert_entry_bh);
1433
1434 mlog_exit(status);
1435
1436 return status;
1437 }
1438
1439 /*
1440 * we expect i_size = strlen(symname). Copy symname into the file
1441 * data, including the null terminator.
1442 */
1443 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1444 handle_t *handle,
1445 struct inode *inode,
1446 const char *symname)
1447 {
1448 struct buffer_head **bhs = NULL;
1449 const char *c;
1450 struct super_block *sb = osb->sb;
1451 u64 p_blkno, p_blocks;
1452 int virtual, blocks, status, i, bytes_left;
1453
1454 bytes_left = i_size_read(inode) + 1;
1455 /* we can't trust i_blocks because we're actually going to
1456 * write i_size + 1 bytes. */
1457 blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1458
1459 mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
1460 (unsigned long long)inode->i_blocks,
1461 i_size_read(inode), blocks);
1462
1463 /* Sanity check -- make sure we're going to fit. */
1464 if (bytes_left >
1465 ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1466 status = -EIO;
1467 mlog_errno(status);
1468 goto bail;
1469 }
1470
1471 bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1472 if (!bhs) {
1473 status = -ENOMEM;
1474 mlog_errno(status);
1475 goto bail;
1476 }
1477
1478 status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1479 NULL);
1480 if (status < 0) {
1481 mlog_errno(status);
1482 goto bail;
1483 }
1484
1485 /* links can never be larger than one cluster so we know this
1486 * is all going to be contiguous, but do a sanity check
1487 * anyway. */
1488 if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1489 status = -EIO;
1490 mlog_errno(status);
1491 goto bail;
1492 }
1493
1494 virtual = 0;
1495 while(bytes_left > 0) {
1496 c = &symname[virtual * sb->s_blocksize];
1497
1498 bhs[virtual] = sb_getblk(sb, p_blkno);
1499 if (!bhs[virtual]) {
1500 status = -ENOMEM;
1501 mlog_errno(status);
1502 goto bail;
1503 }
1504 ocfs2_set_new_buffer_uptodate(inode, bhs[virtual]);
1505
1506 status = ocfs2_journal_access(handle, inode, bhs[virtual],
1507 OCFS2_JOURNAL_ACCESS_CREATE);
1508 if (status < 0) {
1509 mlog_errno(status);
1510 goto bail;
1511 }
1512
1513 memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1514
1515 memcpy(bhs[virtual]->b_data, c,
1516 (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1517 bytes_left);
1518
1519 status = ocfs2_journal_dirty(handle, bhs[virtual]);
1520 if (status < 0) {
1521 mlog_errno(status);
1522 goto bail;
1523 }
1524
1525 virtual++;
1526 p_blkno++;
1527 bytes_left -= sb->s_blocksize;
1528 }
1529
1530 status = 0;
1531 bail:
1532
1533 if (bhs) {
1534 for(i = 0; i < blocks; i++)
1535 brelse(bhs[i]);
1536 kfree(bhs);
1537 }
1538
1539 mlog_exit(status);
1540 return status;
1541 }
1542
1543 static int ocfs2_symlink(struct inode *dir,
1544 struct dentry *dentry,
1545 const char *symname)
1546 {
1547 int status, l, credits;
1548 u64 newsize;
1549 struct ocfs2_super *osb = NULL;
1550 struct inode *inode = NULL;
1551 struct super_block *sb;
1552 struct buffer_head *new_fe_bh = NULL;
1553 struct buffer_head *de_bh = NULL;
1554 struct buffer_head *parent_fe_bh = NULL;
1555 struct ocfs2_dinode *fe = NULL;
1556 struct ocfs2_dinode *dirfe;
1557 handle_t *handle = NULL;
1558 struct ocfs2_alloc_context *inode_ac = NULL;
1559 struct ocfs2_alloc_context *data_ac = NULL;
1560 struct ocfs2_alloc_context *xattr_ac = NULL;
1561 int want_clusters = 0;
1562 int xattr_credits = 0;
1563 struct ocfs2_security_xattr_info si = {
1564 .enable = 1,
1565 };
1566
1567 mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir,
1568 dentry, symname, dentry->d_name.len, dentry->d_name.name);
1569
1570 sb = dir->i_sb;
1571 osb = OCFS2_SB(sb);
1572
1573 l = strlen(symname) + 1;
1574
1575 credits = ocfs2_calc_symlink_credits(sb);
1576
1577 /* lock the parent directory */
1578 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1579 if (status < 0) {
1580 if (status != -ENOENT)
1581 mlog_errno(status);
1582 return status;
1583 }
1584
1585 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1586 if (!dirfe->i_links_count) {
1587 /* can't make a file in a deleted directory. */
1588 status = -ENOENT;
1589 goto bail;
1590 }
1591
1592 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1593 dentry->d_name.len);
1594 if (status)
1595 goto bail;
1596
1597 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1598 dentry->d_name.name,
1599 dentry->d_name.len, &de_bh);
1600 if (status < 0) {
1601 mlog_errno(status);
1602 goto bail;
1603 }
1604
1605 status = ocfs2_reserve_new_inode(osb, &inode_ac);
1606 if (status < 0) {
1607 if (status != -ENOSPC)
1608 mlog_errno(status);
1609 goto bail;
1610 }
1611
1612 inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
1613 if (!inode) {
1614 status = -ENOMEM;
1615 mlog_errno(status);
1616 goto bail;
1617 }
1618
1619 /* get security xattr */
1620 status = ocfs2_init_security_get(inode, dir, &si);
1621 if (status) {
1622 if (status == -EOPNOTSUPP)
1623 si.enable = 0;
1624 else {
1625 mlog_errno(status);
1626 goto bail;
1627 }
1628 }
1629
1630 /* calculate meta data/clusters for setting security xattr */
1631 if (si.enable) {
1632 status = ocfs2_calc_security_init(dir, &si, &want_clusters,
1633 &xattr_credits, &xattr_ac);
1634 if (status < 0) {
1635 mlog_errno(status);
1636 goto bail;
1637 }
1638 }
1639
1640 /* don't reserve bitmap space for fast symlinks. */
1641 if (l > ocfs2_fast_symlink_chars(sb))
1642 want_clusters += 1;
1643
1644 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
1645 if (status < 0) {
1646 if (status != -ENOSPC)
1647 mlog_errno(status);
1648 goto bail;
1649 }
1650
1651 handle = ocfs2_start_trans(osb, credits + xattr_credits);
1652 if (IS_ERR(handle)) {
1653 status = PTR_ERR(handle);
1654 handle = NULL;
1655 mlog_errno(status);
1656 goto bail;
1657 }
1658
1659 status = ocfs2_mknod_locked(osb, dir, inode, dentry,
1660 0, &new_fe_bh, parent_fe_bh, handle,
1661 inode_ac);
1662 if (status < 0) {
1663 mlog_errno(status);
1664 goto bail;
1665 }
1666
1667 fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1668 inode->i_rdev = 0;
1669 newsize = l - 1;
1670 if (l > ocfs2_fast_symlink_chars(sb)) {
1671 u32 offset = 0;
1672
1673 inode->i_op = &ocfs2_symlink_inode_operations;
1674 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
1675 new_fe_bh,
1676 handle, data_ac, NULL,
1677 NULL);
1678 if (status < 0) {
1679 if (status != -ENOSPC && status != -EINTR) {
1680 mlog(ML_ERROR,
1681 "Failed to extend file to %llu\n",
1682 (unsigned long long)newsize);
1683 mlog_errno(status);
1684 status = -ENOSPC;
1685 }
1686 goto bail;
1687 }
1688 i_size_write(inode, newsize);
1689 inode->i_blocks = ocfs2_inode_sector_count(inode);
1690 } else {
1691 inode->i_op = &ocfs2_fast_symlink_inode_operations;
1692 memcpy((char *) fe->id2.i_symlink, symname, l);
1693 i_size_write(inode, newsize);
1694 inode->i_blocks = 0;
1695 }
1696
1697 status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1698 if (status < 0) {
1699 mlog_errno(status);
1700 goto bail;
1701 }
1702
1703 if (!ocfs2_inode_is_fast_symlink(inode)) {
1704 status = ocfs2_create_symlink_data(osb, handle, inode,
1705 symname);
1706 if (status < 0) {
1707 mlog_errno(status);
1708 goto bail;
1709 }
1710 }
1711
1712 if (si.enable) {
1713 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
1714 xattr_ac, data_ac);
1715 if (status < 0) {
1716 mlog_errno(status);
1717 goto bail;
1718 }
1719 }
1720
1721 status = ocfs2_add_entry(handle, dentry, inode,
1722 le64_to_cpu(fe->i_blkno), parent_fe_bh,
1723 de_bh);
1724 if (status < 0) {
1725 mlog_errno(status);
1726 goto bail;
1727 }
1728
1729 status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
1730 if (status) {
1731 mlog_errno(status);
1732 goto bail;
1733 }
1734
1735 insert_inode_hash(inode);
1736 dentry->d_op = &ocfs2_dentry_ops;
1737 d_instantiate(dentry, inode);
1738 bail:
1739 if (handle)
1740 ocfs2_commit_trans(osb, handle);
1741
1742 ocfs2_inode_unlock(dir, 1);
1743
1744 brelse(new_fe_bh);
1745 brelse(parent_fe_bh);
1746 brelse(de_bh);
1747 kfree(si.name);
1748 kfree(si.value);
1749 if (inode_ac)
1750 ocfs2_free_alloc_context(inode_ac);
1751 if (data_ac)
1752 ocfs2_free_alloc_context(data_ac);
1753 if (xattr_ac)
1754 ocfs2_free_alloc_context(xattr_ac);
1755 if ((status < 0) && inode) {
1756 clear_nlink(inode);
1757 iput(inode);
1758 }
1759
1760 mlog_exit(status);
1761
1762 return status;
1763 }
1764
1765 static int ocfs2_blkno_stringify(u64 blkno, char *name)
1766 {
1767 int status, namelen;
1768
1769 mlog_entry_void();
1770
1771 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
1772 (long long)blkno);
1773 if (namelen <= 0) {
1774 if (namelen)
1775 status = namelen;
1776 else
1777 status = -EINVAL;
1778 mlog_errno(status);
1779 goto bail;
1780 }
1781 if (namelen != OCFS2_ORPHAN_NAMELEN) {
1782 status = -EINVAL;
1783 mlog_errno(status);
1784 goto bail;
1785 }
1786
1787 mlog(0, "built filename '%s' for orphan dir (len=%d)\n", name,
1788 namelen);
1789
1790 status = 0;
1791 bail:
1792 mlog_exit(status);
1793 return status;
1794 }
1795
1796 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
1797 struct inode **ret_orphan_dir,
1798 struct inode *inode,
1799 char *name,
1800 struct buffer_head **de_bh)
1801 {
1802 struct inode *orphan_dir_inode;
1803 struct buffer_head *orphan_dir_bh = NULL;
1804 int status = 0;
1805
1806 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
1807 if (status < 0) {
1808 mlog_errno(status);
1809 return status;
1810 }
1811
1812 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
1813 ORPHAN_DIR_SYSTEM_INODE,
1814 osb->slot_num);
1815 if (!orphan_dir_inode) {
1816 status = -ENOENT;
1817 mlog_errno(status);
1818 return status;
1819 }
1820
1821 mutex_lock(&orphan_dir_inode->i_mutex);
1822
1823 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
1824 if (status < 0) {
1825 mlog_errno(status);
1826 goto leave;
1827 }
1828
1829 status = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
1830 orphan_dir_bh, name,
1831 OCFS2_ORPHAN_NAMELEN, de_bh);
1832 if (status < 0) {
1833 ocfs2_inode_unlock(orphan_dir_inode, 1);
1834
1835 mlog_errno(status);
1836 goto leave;
1837 }
1838
1839 *ret_orphan_dir = orphan_dir_inode;
1840
1841 leave:
1842 if (status) {
1843 mutex_unlock(&orphan_dir_inode->i_mutex);
1844 iput(orphan_dir_inode);
1845 }
1846
1847 brelse(orphan_dir_bh);
1848
1849 mlog_exit(status);
1850 return status;
1851 }
1852
1853 static int ocfs2_orphan_add(struct ocfs2_super *osb,
1854 handle_t *handle,
1855 struct inode *inode,
1856 struct ocfs2_dinode *fe,
1857 char *name,
1858 struct buffer_head *de_bh,
1859 struct inode *orphan_dir_inode)
1860 {
1861 struct buffer_head *orphan_dir_bh = NULL;
1862 int status = 0;
1863 struct ocfs2_dinode *orphan_fe;
1864
1865 mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
1866
1867 status = ocfs2_read_block(orphan_dir_inode,
1868 OCFS2_I(orphan_dir_inode)->ip_blkno,
1869 &orphan_dir_bh);
1870 if (status < 0) {
1871 mlog_errno(status);
1872 goto leave;
1873 }
1874
1875 status = ocfs2_journal_access(handle, orphan_dir_inode, orphan_dir_bh,
1876 OCFS2_JOURNAL_ACCESS_WRITE);
1877 if (status < 0) {
1878 mlog_errno(status);
1879 goto leave;
1880 }
1881
1882 /* we're a cluster, and nlink can change on disk from
1883 * underneath us... */
1884 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
1885 if (S_ISDIR(inode->i_mode))
1886 le16_add_cpu(&orphan_fe->i_links_count, 1);
1887 orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
1888
1889 status = ocfs2_journal_dirty(handle, orphan_dir_bh);
1890 if (status < 0) {
1891 mlog_errno(status);
1892 goto leave;
1893 }
1894
1895 status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
1896 OCFS2_ORPHAN_NAMELEN, inode,
1897 OCFS2_I(inode)->ip_blkno,
1898 orphan_dir_bh, de_bh);
1899 if (status < 0) {
1900 mlog_errno(status);
1901 goto leave;
1902 }
1903
1904 le32_add_cpu(&fe->i_flags, OCFS2_ORPHANED_FL);
1905
1906 /* Record which orphan dir our inode now resides
1907 * in. delete_inode will use this to determine which orphan
1908 * dir to lock. */
1909 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
1910
1911 mlog(0, "Inode %llu orphaned in slot %d\n",
1912 (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
1913
1914 leave:
1915 brelse(orphan_dir_bh);
1916
1917 mlog_exit(status);
1918 return status;
1919 }
1920
1921 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
1922 int ocfs2_orphan_del(struct ocfs2_super *osb,
1923 handle_t *handle,
1924 struct inode *orphan_dir_inode,
1925 struct inode *inode,
1926 struct buffer_head *orphan_dir_bh)
1927 {
1928 char name[OCFS2_ORPHAN_NAMELEN + 1];
1929 struct ocfs2_dinode *orphan_fe;
1930 int status = 0;
1931 struct buffer_head *target_de_bh = NULL;
1932 struct ocfs2_dir_entry *target_de = NULL;
1933
1934 mlog_entry_void();
1935
1936 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
1937 if (status < 0) {
1938 mlog_errno(status);
1939 goto leave;
1940 }
1941
1942 mlog(0, "removing '%s' from orphan dir %llu (namelen=%d)\n",
1943 name, (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
1944 OCFS2_ORPHAN_NAMELEN);
1945
1946 /* find it's spot in the orphan directory */
1947 target_de_bh = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN,
1948 orphan_dir_inode, &target_de);
1949 if (!target_de_bh) {
1950 status = -ENOENT;
1951 mlog_errno(status);
1952 goto leave;
1953 }
1954
1955 /* remove it from the orphan directory */
1956 status = ocfs2_delete_entry(handle, orphan_dir_inode, target_de,
1957 target_de_bh);
1958 if (status < 0) {
1959 mlog_errno(status);
1960 goto leave;
1961 }
1962
1963 status = ocfs2_journal_access(handle,orphan_dir_inode, orphan_dir_bh,
1964 OCFS2_JOURNAL_ACCESS_WRITE);
1965 if (status < 0) {
1966 mlog_errno(status);
1967 goto leave;
1968 }
1969
1970 /* do the i_nlink dance! :) */
1971 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
1972 if (S_ISDIR(inode->i_mode))
1973 le16_add_cpu(&orphan_fe->i_links_count, -1);
1974 orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
1975
1976 status = ocfs2_journal_dirty(handle, orphan_dir_bh);
1977 if (status < 0) {
1978 mlog_errno(status);
1979 goto leave;
1980 }
1981
1982 leave:
1983 brelse(target_de_bh);
1984
1985 mlog_exit(status);
1986 return status;
1987 }
1988
1989 const struct inode_operations ocfs2_dir_iops = {
1990 .create = ocfs2_create,
1991 .lookup = ocfs2_lookup,
1992 .link = ocfs2_link,
1993 .unlink = ocfs2_unlink,
1994 .rmdir = ocfs2_unlink,
1995 .symlink = ocfs2_symlink,
1996 .mkdir = ocfs2_mkdir,
1997 .mknod = ocfs2_mknod,
1998 .rename = ocfs2_rename,
1999 .setattr = ocfs2_setattr,
2000 .getattr = ocfs2_getattr,
2001 .permission = ocfs2_permission,
2002 .setxattr = generic_setxattr,
2003 .getxattr = generic_getxattr,
2004 .listxattr = ocfs2_listxattr,
2005 .removexattr = generic_removexattr,
2006 };
(deprecated) Btrfs devel tree