block: avoid unconditionally freeing previously allocated request_queue

[safe/jmp/linux-2.6] / fs / dlm / dir.c

diff --git a/fs/dlm/dir.c b/fs/dlm/dir.c
index ff97ba9..7b84c1d 100644 (file)
--- a/fs/dlm/dir.c
+++ b/fs/dlm/dir.c
@@ -49,7 +49,7 @@ static struct dlm_direntry *get_free_de(struct dlm_ls *ls, int len)
        spin_unlock(&ls->ls_recover_list_lock);
 
        if (!found)
-               de = kzalloc(sizeof(struct dlm_direntry) + len, GFP_KERNEL);
+               de = kzalloc(sizeof(struct dlm_direntry) + len, GFP_NOFS);
        return de;
 }
 
@@ -156,7 +156,7 @@ void dlm_dir_remove_entry(struct dlm_ls *ls, int nodeid, char *name, int namelen
 
        bucket = dir_hash(ls, name, namelen);
 
-       write_lock(&ls->ls_dirtbl[bucket].lock);
+       spin_lock(&ls->ls_dirtbl[bucket].lock);
 
        de = search_bucket(ls, name, namelen, bucket);
 
@@ -173,7 +173,7 @@ void dlm_dir_remove_entry(struct dlm_ls *ls, int nodeid, char *name, int namelen
        list_del(&de->list);
        kfree(de);
  out:
-       write_unlock(&ls->ls_dirtbl[bucket].lock);
+       spin_unlock(&ls->ls_dirtbl[bucket].lock);
 }
 
 void dlm_dir_clear(struct dlm_ls *ls)
@@ -185,14 +185,14 @@ void dlm_dir_clear(struct dlm_ls *ls)
        DLM_ASSERT(list_empty(&ls->ls_recover_list), );
 
        for (i = 0; i < ls->ls_dirtbl_size; i++) {
-               write_lock(&ls->ls_dirtbl[i].lock);
+               spin_lock(&ls->ls_dirtbl[i].lock);
                head = &ls->ls_dirtbl[i].list;
                while (!list_empty(head)) {
                        de = list_entry(head->next, struct dlm_direntry, list);
                        list_del(&de->list);
                        put_free_de(ls, de);
                }
-               write_unlock(&ls->ls_dirtbl[i].lock);
+               spin_unlock(&ls->ls_dirtbl[i].lock);
        }
 }
 
@@ -211,7 +211,7 @@ int dlm_recover_directory(struct dlm_ls *ls)
 
        dlm_dir_clear(ls);
 
-       last_name = kmalloc(DLM_RESNAME_MAXLEN, GFP_KERNEL);
+       last_name = kmalloc(DLM_RESNAME_MAXLEN, GFP_NOFS);
        if (!last_name)
                goto out;
 
@@ -220,6 +220,7 @@ int dlm_recover_directory(struct dlm_ls *ls)
                last_len = 0;
 
                for (;;) {
+                       int left;
                        error = dlm_recovery_stopped(ls);
                        if (error)
                                goto out_free;
@@ -235,12 +236,21 @@ int dlm_recover_directory(struct dlm_ls *ls)
                         * pick namelen/name pairs out of received buffer
                         */
 
-                       b = ls->ls_recover_buf + sizeof(struct dlm_rcom);
+                       b = ls->ls_recover_buf->rc_buf;
+                       left = ls->ls_recover_buf->rc_header.h_length;
+                       left -= sizeof(struct dlm_rcom);
 
                        for (;;) {
-                               memcpy(&namelen, b, sizeof(uint16_t));
-                               namelen = be16_to_cpu(namelen);
-                               b += sizeof(uint16_t);
+                               __be16 v;
+
+                               error = -EINVAL;
+                               if (left < sizeof(__be16))
+                                       goto out_free;
+
+                               memcpy(&v, b, sizeof(__be16));
+                               namelen = be16_to_cpu(v);
+                               b += sizeof(__be16);
+                               left -= sizeof(__be16);
 
                                /* namelen of 0xFFFFF marks end of names for
                                   this node; namelen of 0 marks end of the
@@ -251,6 +261,12 @@ int dlm_recover_directory(struct dlm_ls *ls)
                                if (!namelen)
                                        break;
 
+                               if (namelen > left)
+                                       goto out_free;
+
+                               if (namelen > DLM_RESNAME_MAXLEN)
+                                       goto out_free;
+
                                error = -ENOMEM;
                                de = get_free_de(ls, namelen);
                                if (!de)
@@ -262,6 +278,7 @@ int dlm_recover_directory(struct dlm_ls *ls)
                                memcpy(de->name, b, namelen);
                                memcpy(last_name, b, namelen);
                                b += namelen;
+                               left -= namelen;
 
                                add_entry_to_hash(ls, de);
                                count++;
@@ -290,19 +307,22 @@ static int get_entry(struct dlm_ls *ls, int nodeid, char *name,
 
        bucket = dir_hash(ls, name, namelen);
 
-       write_lock(&ls->ls_dirtbl[bucket].lock);
+       spin_lock(&ls->ls_dirtbl[bucket].lock);
        de = search_bucket(ls, name, namelen, bucket);
        if (de) {
                *r_nodeid = de->master_nodeid;
-               write_unlock(&ls->ls_dirtbl[bucket].lock);
+               spin_unlock(&ls->ls_dirtbl[bucket].lock);
                if (*r_nodeid == nodeid)
                        return -EEXIST;
                return 0;
        }
 
-       write_unlock(&ls->ls_dirtbl[bucket].lock);
+       spin_unlock(&ls->ls_dirtbl[bucket].lock);
+
+       if (namelen > DLM_RESNAME_MAXLEN)
+               return -EINVAL;
 
-       de = kzalloc(sizeof(struct dlm_direntry) + namelen, GFP_KERNEL);
+       de = kzalloc(sizeof(struct dlm_direntry) + namelen, GFP_NOFS);
        if (!de)
                return -ENOMEM;
 
@@ -310,7 +330,7 @@ static int get_entry(struct dlm_ls *ls, int nodeid, char *name,
        de->length = namelen;
        memcpy(de->name, name, namelen);
 
-       write_lock(&ls->ls_dirtbl[bucket].lock);
+       spin_lock(&ls->ls_dirtbl[bucket].lock);
        tmp = search_bucket(ls, name, namelen, bucket);
        if (tmp) {
                kfree(de);
@@ -319,7 +339,7 @@ static int get_entry(struct dlm_ls *ls, int nodeid, char *name,
                list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
        }
        *r_nodeid = de->master_nodeid;
-       write_unlock(&ls->ls_dirtbl[bucket].lock);
+       spin_unlock(&ls->ls_dirtbl[bucket].lock);
        return 0;
 }
 
@@ -354,7 +374,7 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
        struct list_head *list;
        struct dlm_rsb *r;
        int offset = 0, dir_nodeid;
-       uint16_t be_namelen;
+       __be16 be_namelen;
 
        down_read(&ls->ls_root_sem);
 
@@ -390,15 +410,15 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
 
                if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {
                        /* Write end-of-block record */
-                       be_namelen = 0;
-                       memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
-                       offset += sizeof(uint16_t);
+                       be_namelen = cpu_to_be16(0);
+                       memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+                       offset += sizeof(__be16);
                        goto out;
                }
 
                be_namelen = cpu_to_be16(r->res_length);
-               memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
-               offset += sizeof(uint16_t);
+               memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+               offset += sizeof(__be16);
                memcpy(outbuf + offset, r->res_name, r->res_length);
                offset += r->res_length;
        }
@@ -410,9 +430,9 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
 
        if ((list == &ls->ls_root_list) &&
            (offset + sizeof(uint16_t) <= outlen)) {
-               be_namelen = 0xFFFF;
-               memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
-               offset += sizeof(uint16_t);
+               be_namelen = cpu_to_be16(0xFFFF);
+               memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+               offset += sizeof(__be16);
        }
 
  out: