/* SMP-safe */
 static struct dentry *proc_pident_lookup(struct inode *dir, 
                                         struct dentry *dentry,
-                                        struct pid_entry *ents)
+                                        struct pid_entry *ents,
+                                        unsigned int nents)
 {
        struct inode *inode;
        struct dentry *error;
        struct task_struct *task = get_proc_task(dir);
-       struct pid_entry *p;
+       struct pid_entry *p, *last;
 
        error = ERR_PTR(-ENOENT);
        inode = NULL;
         * Yes, it does not scale. And it should not. Don't add
         * new entries into /proc/<tgid>/ without very good reasons.
         */
-       for (p = ents; p->name; p++) {
+       last = &ents[nents - 1];
+       for (p = ents; p <= last; p++) {
                if (p->len != dentry->d_name.len)
                        continue;
                if (!memcmp(dentry->d_name.name, p->name, p->len))
                        break;
        }
-       if (!p->name)
+       if (p > last)
                goto out;
 
        error = proc_pident_instantiate(dir, dentry, task, p);
        struct dentry *dentry = filp->f_dentry;
        struct inode *inode = dentry->d_inode;
        struct task_struct *task = get_proc_task(inode);
-       struct pid_entry *p;
+       struct pid_entry *p, *last;
        ino_t ino;
        int ret;
 
                        goto out;
                }
                p = ents + i;
-               while (p->name) {
+               last = &ents[nents - 1];
+               while (p <= last) {
                        if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
                                goto out;
                        filp->f_pos++;
        REG("fscreate",   S_IRUGO|S_IWUGO, pid_attr),
        REG("keycreate",  S_IRUGO|S_IWUGO, pid_attr),
        REG("sockcreate", S_IRUGO|S_IWUGO, pid_attr),
-       {}
 };
 
 static int proc_attr_dir_readdir(struct file * filp,
 static struct dentry *proc_attr_dir_lookup(struct inode *dir,
                                struct dentry *dentry, struct nameidata *nd)
 {
-       return proc_pident_lookup(dir, dentry, attr_dir_stuff);
+       return proc_pident_lookup(dir, dentry,
+                                 attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
 }
 
 static struct inode_operations proc_attr_dir_inode_operations = {
 static struct pid_entry proc_base_stuff[] = {
        NOD("self", S_IFLNK|S_IRWXUGO,
                &proc_self_inode_operations, NULL, {}),
-       {}
 };
 
 /*
 {
        struct dentry *error;
        struct task_struct *task = get_proc_task(dir);
-       struct pid_entry *p;
+       struct pid_entry *p, *last;
 
        error = ERR_PTR(-ENOENT);
 
                goto out_no_task;
 
        /* Lookup the directory entry */
-       for (p = proc_base_stuff; p->name; p++) {
+       last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1];
+       for (p = proc_base_stuff; p <= last; p++) {
                if (p->len != dentry->d_name.len)
                        continue;
                if (!memcmp(dentry->d_name.name, p->name, p->len))
                        break;
        }
-       if (!p->name)
+       if (p > last)
                goto out;
 
        error = proc_base_instantiate(dir, dentry, task, p);
 #ifdef CONFIG_AUDITSYSCALL
        REG("loginuid",   S_IWUSR|S_IRUGO, loginuid),
 #endif
-       {}
 };
 
 static int proc_tgid_base_readdir(struct file * filp,
 };
 
 static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
-       return proc_pident_lookup(dir, dentry, tgid_base_stuff);
+       return proc_pident_lookup(dir, dentry,
+                                 tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
 }
 
 static struct inode_operations proc_tgid_base_inode_operations = {
        return task;
 }
 
-#define TGID_OFFSET (FIRST_PROCESS_ENTRY + (ARRAY_SIZE(proc_base_stuff) - 1))
+#define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff))
 
 static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
        struct task_struct *task, int tgid)
        if (!reaper)
                goto out_no_task;
 
-       for (; nr < (ARRAY_SIZE(proc_base_stuff) - 1); filp->f_pos++, nr++) {
+       for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) {
                struct pid_entry *p = &proc_base_stuff[nr];
                if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0)
                        goto out;
 #ifdef CONFIG_AUDITSYSCALL
        REG("loginuid",  S_IWUSR|S_IRUGO, loginuid),
 #endif
-       {}
 };
 
 static int proc_tid_base_readdir(struct file * filp,
 }
 
 static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
-       return proc_pident_lookup(dir, dentry, tid_base_stuff);
+       return proc_pident_lookup(dir, dentry,
+                                 tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
 }
 
 static struct file_operations proc_tid_base_operations = {