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