Root/fs/ocfs2/namei.c

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

Archive Download this file



interactive