10 files changed, 38 insertions, 26 deletions

diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index e4effc47abfc..e9456ebd3bb6 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -932,7 +932,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping)
         if (!gfs2_is_writeback(ip))
                 gfs2_trans_add_bh(ip->i_gl, bh, 0);
 
-        zero_user_page(page, offset, length, KM_USER0);
+        zero_user(page, offset, length);
 
 unlock:
         unlock_page(page);
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 57e2ed932adc..c34709512b19 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -1498,7 +1498,7 @@ struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
         dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
         if (dent) {
                 if (IS_ERR(dent))
-                        return ERR_PTR(PTR_ERR(dent));
+                        return ERR_CAST(dent);
                 inode = gfs2_inode_lookup(dir->i_sb, 
                                 be16_to_cpu(dent->de_type),
                                 be64_to_cpu(dent->de_inum.no_addr),
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 80e09c50590a..7175a4d06435 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -334,7 +334,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
         gl->gl_state = LM_ST_UNLOCKED;
         gl->gl_demote_state = LM_ST_EXCLUSIVE;
         gl->gl_hash = hash;
-        gl->gl_owner_pid = 0;
+        gl->gl_owner_pid = NULL;
         gl->gl_ip = 0;
         gl->gl_ops = glops;
         gl->gl_req_gh = NULL;
@@ -399,7 +399,7 @@ void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, unsigned flags,
         INIT_LIST_HEAD(&gh->gh_list);
         gh->gh_gl = gl;
         gh->gh_ip = (unsigned long)__builtin_return_address(0);
-        gh->gh_owner_pid = current->pid;
+        gh->gh_owner_pid = get_pid(task_pid(current));
         gh->gh_state = state;
         gh->gh_flags = flags;
         gh->gh_error = 0;
@@ -433,6 +433,7 @@ void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *
 
 void gfs2_holder_uninit(struct gfs2_holder *gh)
 {
+        put_pid(gh->gh_owner_pid);
         gfs2_glock_put(gh->gh_gl);
         gh->gh_gl = NULL;
         gh->gh_ip = 0;
@@ -631,7 +632,7 @@ static void gfs2_glmutex_lock(struct gfs2_glock *gl)
                 wait_on_holder(&gh);
                 gfs2_holder_uninit(&gh);
         } else {
-                gl->gl_owner_pid = current->pid;
+                gl->gl_owner_pid = get_pid(task_pid(current));
                 gl->gl_ip = (unsigned long)__builtin_return_address(0);
                 spin_unlock(&gl->gl_spin);
         }
@@ -652,7 +653,7 @@ static int gfs2_glmutex_trylock(struct gfs2_glock *gl)
         if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
                 acquired = 0;
         } else {
-                gl->gl_owner_pid = current->pid;
+                gl->gl_owner_pid = get_pid(task_pid(current));
                 gl->gl_ip = (unsigned long)__builtin_return_address(0);
         }
         spin_unlock(&gl->gl_spin);
@@ -668,12 +669,17 @@ static int gfs2_glmutex_trylock(struct gfs2_glock *gl)
 
 static void gfs2_glmutex_unlock(struct gfs2_glock *gl)
 {
+        struct pid *pid;
+
         spin_lock(&gl->gl_spin);
         clear_bit(GLF_LOCK, &gl->gl_flags);
-        gl->gl_owner_pid = 0;
+        pid = gl->gl_owner_pid;
+        gl->gl_owner_pid = NULL;
         gl->gl_ip = 0;
         run_queue(gl);
         spin_unlock(&gl->gl_spin);
+
+        put_pid(pid);
 }
 
 /**
@@ -1045,7 +1051,7 @@ static int glock_wait_internal(struct gfs2_holder *gh)
 }
 
 static inline struct gfs2_holder *
-find_holder_by_owner(struct list_head *head, pid_t pid)
+find_holder_by_owner(struct list_head *head, struct pid *pid)
 {
         struct gfs2_holder *gh;
 
@@ -1082,7 +1088,7 @@ static void add_to_queue(struct gfs2_holder *gh)
         struct gfs2_glock *gl = gh->gh_gl;
         struct gfs2_holder *existing;
 
-        BUG_ON(!gh->gh_owner_pid);
+        BUG_ON(gh->gh_owner_pid == NULL);
         if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
                 BUG();
 
@@ -1092,12 +1098,14 @@ static void add_to_queue(struct gfs2_holder *gh)
                 if (existing) {
                         print_symbol(KERN_WARNING "original: %s\n", 
                                      existing->gh_ip);
-                        printk(KERN_INFO "pid : %d\n", existing->gh_owner_pid);
+                        printk(KERN_INFO "pid : %d\n",
+                                        pid_nr(existing->gh_owner_pid));
                         printk(KERN_INFO "lock type : %d lock state : %d\n",
                                existing->gh_gl->gl_name.ln_type, 
                                existing->gh_gl->gl_state);
                         print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
-                        printk(KERN_INFO "pid : %d\n", gh->gh_owner_pid);
+                        printk(KERN_INFO "pid : %d\n",
+                                        pid_nr(gh->gh_owner_pid));
                         printk(KERN_INFO "lock type : %d lock state : %d\n",
                                gl->gl_name.ln_type, gl->gl_state);
                         BUG();
@@ -1798,8 +1806,9 @@ static int dump_holder(struct glock_iter *gi, char *str,
 
         print_dbg(gi, "  %s\n", str);
         if (gh->gh_owner_pid) {
-                print_dbg(gi, "    owner = %ld ", (long)gh->gh_owner_pid);
-                gh_owner = find_task_by_pid(gh->gh_owner_pid);
+                print_dbg(gi, "    owner = %ld ",
+                                (long)pid_nr(gh->gh_owner_pid));
+                gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
                 if (gh_owner)
                         print_dbg(gi, "(%s)\n", gh_owner->comm);
                 else
@@ -1877,13 +1886,13 @@ static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl)
         print_dbg(gi, "  gl_ref = %d\n", atomic_read(&gl->gl_ref));
         print_dbg(gi, "  gl_state = %u\n", gl->gl_state);
         if (gl->gl_owner_pid) {
-                gl_owner = find_task_by_pid(gl->gl_owner_pid);
+                gl_owner = pid_task(gl->gl_owner_pid, PIDTYPE_PID);
                 if (gl_owner)
                         print_dbg(gi, "  gl_owner = pid %d (%s)\n",
-                                  gl->gl_owner_pid, gl_owner->comm);
+                                  pid_nr(gl->gl_owner_pid), gl_owner->comm);
                 else
                         print_dbg(gi, "  gl_owner = %d (ended)\n",
-                                  gl->gl_owner_pid);
+                                  pid_nr(gl->gl_owner_pid));
         } else
                 print_dbg(gi, "  gl_owner = -1\n");
         print_dbg(gi, "  gl_ip = %lu\n", gl->gl_ip);
diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h
index b16f604eea9f..2f9c6d136b37 100644
--- a/fs/gfs2/glock.h
+++ b/fs/gfs2/glock.h
@@ -36,11 +36,13 @@ static inline int gfs2_glock_is_locked_by_me(struct gfs2_glock *gl)
 {
         struct gfs2_holder *gh;
         int locked = 0;
+        struct pid *pid;
 
         /* Look in glock's list of holders for one with current task as owner */
         spin_lock(&gl->gl_spin);
+        pid = task_pid(current);
         list_for_each_entry(gh, &gl->gl_holders, gh_list) {
-                if (gh->gh_owner_pid == current->pid) {
+                if (gh->gh_owner_pid == pid) {
                         locked = 1;
                         break;
                 }
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 513aaf0dc0ab..525dcae352d6 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -151,7 +151,7 @@ struct gfs2_holder {
         struct list_head gh_list;
 
         struct gfs2_glock *gh_gl;
-        pid_t gh_owner_pid;
+        struct pid *gh_owner_pid;
         unsigned int gh_state;
         unsigned gh_flags;
 
@@ -182,7 +182,7 @@ struct gfs2_glock {
         unsigned int gl_hash;
         unsigned int gl_demote_state; /* state requested by remote node */
         unsigned long gl_demote_time; /* time of first demote request */
-        pid_t gl_owner_pid;
+        struct pid *gl_owner_pid;
         unsigned long gl_ip;
         struct list_head gl_holders;
         struct list_head gl_waiters1;   /* HIF_MUTEX */
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 728d3169e7bd..37725ade3c51 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -240,7 +240,7 @@ fail_put:
         ip->i_gl->gl_object = NULL;
         gfs2_glock_put(ip->i_gl);
 fail:
-        iput(inode);
+        iget_failed(inode);
         return ERR_PTR(error);
 }
 
diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
index 38dbe99a30ed..ac772b6d9dbb 100644
--- a/fs/gfs2/ops_address.c
+++ b/fs/gfs2/ops_address.c
@@ -446,7 +446,7 @@ static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
          * so we need to supply one here. It doesn't happen often.
          */
         if (unlikely(page->index)) {
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
                 return 0;
         }
 
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
index b9da62348a87..334c7f85351b 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/ops_export.c
@@ -143,7 +143,7 @@ static struct dentry *gfs2_get_parent(struct dentry *child)
          * have to return that as a(n invalid) pointer to dentry.
          */
         if (IS_ERR(inode))
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
 
         dentry = d_alloc_anon(inode);
         if (!dentry) {
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 43d511bba52d..4bee6aa845e4 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -884,12 +884,13 @@ static struct super_block* get_gfs2_sb(const char *dev_name)
                        dev_name);
                 goto out;
         }
-        error = vfs_getattr(nd.mnt, nd.dentry, &stat);
+        error = vfs_getattr(nd.path.mnt, nd.path.dentry, &stat);
 
         fstype = get_fs_type("gfs2");
         list_for_each_entry(s, &fstype->fs_supers, s_instances) {
                 if ((S_ISBLK(stat.mode) && s->s_dev == stat.rdev) ||
-                    (S_ISDIR(stat.mode) && s == nd.dentry->d_inode->i_sb)) {
+                    (S_ISDIR(stat.mode) &&
+                     s == nd.path.dentry->d_inode->i_sb)) {
                         sb = s;
                         goto free_nd;
                 }
@@ -899,7 +900,7 @@ static struct super_block* get_gfs2_sb(const char *dev_name)
                "mount point %s\n", dev_name);
 
 free_nd:
-        path_release(&nd);
+        path_put(&nd.path);
 out:
         return sb;
 }
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index 9f71372c1757..e87412902bed 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -111,7 +111,7 @@ static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 
         inode = gfs2_lookupi(dir, &dentry->d_name, 0, nd);
         if (inode && IS_ERR(inode))
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
 
         if (inode) {
                 struct gfs2_glock *gl = GFS2_I(inode)->i_gl;