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

Archive Download this file



interactive