int ocfs2_node_map_iterate(struct ocfs2_super *osb,
                           struct ocfs2_node_map *map,
                           int idx)
{
        int i = idx;

        idx = O2NM_INVALID_NODE_NUM;
        spin_lock(&osb->node_map_lock);
        if ((i != O2NM_INVALID_NODE_NUM) &&
            (i >= 0) &&
            (i < map->num_nodes)) {
            /*
         * linux-2.6.20.7/fs/ocfs2/heartbeat.c
         *
         * ￥1
         *
         * oversight bitops of arch version by linux
             */
                while (i < map->num_nodes) {
                        if (test_bit(i, map->map)) {
                                idx = i;
                                break;
                        }
                        i++;
                }
        }
        spin_unlock(&osb->node_map_lock);
        return idx;
}

int vfs_rmdir(struct inode *dir, struct dentry *dentry)
{
        int error = may_delete(dir, dentry, 1);

        if (error)
                return error;

        if (!dir->i_op || !dir->i_op->rmdir)
                return -EPERM;

        DQUOT_INIT(dir);

        mutex_lock(&dentry->d_inode->i_mutex);
        dentry_unhash(dentry);
        if (d_mountpoint(dentry))
                error = -EBUSY;
        else {
                error = security_inode_rmdir(dir, dentry);
                if (!error) {
                        error = dir->i_op->rmdir(dir, dentry);
                        if (!error)
                                dentry->d_inode->i_flags |= S_DEAD;
                }
        }
        mutex_unlock(&dentry->d_inode->i_mutex);
        if (!error) {

/*
* linux-2.6.20.7/fs/namei.c
*
* potentially trigger-1
*/
                d_delete(dentry);
        }
        dput(dentry);

        return error;
}

void d_delete(struct dentry * dentry)
{
        int isdir = 0;
        /*
         * Are we the only user?
         */
        spin_lock(&dcache_lock);
        spin_lock(&dentry->d_lock);
        isdir = S_ISDIR(dentry->d_inode->i_mode);
       
        if (atomic_read(&dentry->d_count) == 1) {
                dentry_iput(dentry);
                fsnotify_nameremove(dentry, isdir);

                /* remove this and other inotify debug checks after 2.6.18 */
                dentry->d_flags &= ~DCACHE_INOTIFY_PARENT_WATCHED;

/*
* linux-2.6.20.7/fs/dcache.c
*
* potentially trigger-2
*/
                return;
        }

        if (!d_unhashed(dentry))
                __d_drop(dentry);

        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock);

        fsnotify_nameremove(dentry, isdir);
}

void dput(struct dentry *dentry)
{
        if (!dentry)
                return;

repeat:
        if (atomic_read(&dentry->d_count) == 1)
                might_sleep();
       
        if (!atomic_dec_and_lock(&dentry->d_count, &dcache_lock))
                return;

/*
* linux-2.6.20.7/fs/dcache.c
*
* ￥6
* potentially race @ here
*/
        spin_lock(&dentry->d_lock);
       
        if (atomic_read(&dentry->d_count)) {
                spin_unlock(&dentry->d_lock);
                spin_unlock(&dcache_lock);
                return;
        }

        /*
         * AV: ->d_delete() is _NOT_ allowed to block now.
         */
        if (dentry->d_op && dentry->d_op->d_delete) {
                if (dentry->d_op->d_delete(dentry))
                        goto unhash_it;
        }

        /* Unreachable? Get rid of it */
        if (d_unhashed(dentry))
                goto kill_it;
       
        if (list_empty(&dentry->d_lru)) {
                  dentry->d_flags |= DCACHE_REFERENCED;
                  list_add(&dentry->d_lru, &dentry_unused);
                  dentry_stat.nr_unused++;
          }
        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock);
        return;

unhash_it:
        __d_drop(dentry);

kill_it: {
                struct dentry *parent;

                /* If dentry was on d_lru list,
                 * delete it from there
                 */
                  if (!list_empty(&dentry->d_lru)) {
                          list_del(&dentry->d_lru);
                          dentry_stat.nr_unused--;
                  }
                  list_del(&dentry->d_u.d_child);
                dentry_stat.nr_dentry--;        /* For d_free, below */
               
                /* drops the locks,
                 * at that point nobody can reach this dentry
                 */
                dentry_iput(dentry);
               
                parent = dentry->d_parent;
                d_free(dentry);
               
                if (dentry == parent)
                        return;
                dentry = parent;
                goto repeat;
        }
}

void dput(struct dentry *dentry)
{
        if (!dentry)
                return;

repeat:
        if (atomic_read(&dentry->d_count) == 1)
                might_sleep();
      
        if (!atomic_dec_and_lock(&dentry->d_count, &dcache_lock))
                return;

/*
* linux-2.6.20.7/fs/dcache.c
*
* ￥6
* potentially race @ here
*/
        spin_lock(&dentry->d_lock);
      
        if (atomic_read(&dentry->d_count)) {
                spin_unlock(&dentry->d_lock);
                spin_unlock(&dcache_lock);
                return;
        }

        /*
         * AV: ->d_delete() is _NOT_ allowed to block now.
         */
        if (dentry->d_op && dentry->d_op->d_delete) {
                if (dentry->d_op->d_delete(dentry))
                        goto unhash_it;
        }

        /* Unreachable? Get rid of it */
        if (d_unhashed(dentry))
                goto kill_it;
      
        if (list_empty(&dentry->d_lru)) {
                  dentry->d_flags |= DCACHE_REFERENCED;
                  list_add(&dentry->d_lru, &dentry_unused);
                  dentry_stat.nr_unused++;
          }
        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock);
        return;

unhash_it:
        __d_drop(dentry);

kill_it: {
                struct dentry *parent;

                /* If dentry was on d_lru list,
                 * delete it from there
                 */
                  if (!list_empty(&dentry->d_lru)) {
                          list_del(&dentry->d_lru);
                          dentry_stat.nr_unused--;
                  }
                  list_del(&dentry->d_u.d_child);
                dentry_stat.nr_dentry--;        /* For d_free, below */
               
                /* drops the locks,
                 * at that point nobody can reach this dentry
                 */
                dentry_iput(dentry);
               
                parent = dentry->d_parent;
                d_free(dentry);
               
                if (dentry == parent)
                        return;
                dentry = parent;
                goto repeat;
        }
}

        if (!error) {
                d_delete(dentry);
/*
*  d_delete return potentially without releasing dcache_lock & dentry->d_lock
*/
        }
/*
* however dput at least try to get dentry->d_lock
*/
        dput(dentry);


/*
* yeah, these codes used everyday after bootstrap,
* why not heard bloat???
*/

原帖由 sisi8408 于 2007-8-24 11:22 发表

        if (!error) {
                d_delete(dentry);
/*
*  d_delete return potentially without releasing dcache_lock & dentry->d_lock
*/
        }
/*
* however dput at least try to ...

原帖由 思一克 于 2007-8-24 11:46 发表
你怎么知道d_delete return potentially without releasing dcache_lock & dentry->d_lock？

我看的是2。6。13版本。和你的应该差不多。

原帖由 sisi8408 于 2007-8-24 12:56 发表
天太热，BUG可能躲荫了。
喝杯清茶，回头再看，随手写来，表达个想法，不必当真，呵呵。

原帖由 sisi8408 于 2007-8-24 13:11 发表
如果skipjack用的版本疮上了，这里提个醒，不算太罗唆。

哪个版本稳定呐？不好说，看的人多一点，可能稍好吧。

BUG，俺叫他八哥，一种好听的鸟，养着乐的。