diff options
author | Greg Kroah-Hartman <gregkh@suse.de> | 2011-09-15 15:53:24 +0200 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2011-09-15 15:53:24 +0200 |
commit | e34f28020ca15c5f8842adea20fe8c6fe8f9144f (patch) | |
tree | d395cb6150e4935410854de6f1323f7971573215 | |
parent | 6d3fab99f942f3d286461702bfedf0d16d9911c7 (diff) | |
download | stable-queue-e34f28020ca15c5f8842adea20fe8c6fe8f9144f.tar.gz |
3.0 patches
13 files changed, 1050 insertions, 0 deletions
diff --git a/queue-3.0/9p-close-acl-leaks.patch b/queue-3.0/9p-close-acl-leaks.patch new file mode 100644 index 0000000000..a46744291e --- /dev/null +++ b/queue-3.0/9p-close-acl-leaks.patch @@ -0,0 +1,139 @@ +From 1ec95bf34d976b38897d1977b155a544d77b05e7 Mon Sep 17 00:00:00 2001 +From: Al Viro <viro@zeniv.linux.org.uk> +Date: Sat, 23 Jul 2011 02:28:13 -0400 +Subject: 9p: close ACL leaks + +From: Al Viro <viro@zeniv.linux.org.uk> + +commit 1ec95bf34d976b38897d1977b155a544d77b05e7 upstream. + +Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + fs/9p/acl.c | 22 +++++++++++++--------- + fs/9p/acl.h | 6 +++--- + fs/9p/vfs_inode_dotl.c | 9 ++++++--- + 3 files changed, 22 insertions(+), 15 deletions(-) + +--- a/fs/9p/acl.c ++++ b/fs/9p/acl.c +@@ -185,12 +185,15 @@ int v9fs_acl_chmod(struct dentry *dentry + } + + int v9fs_set_create_acl(struct dentry *dentry, +- struct posix_acl *dpacl, struct posix_acl *pacl) ++ struct posix_acl **dpacl, struct posix_acl **pacl) + { +- v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, dpacl); +- v9fs_set_acl(dentry, ACL_TYPE_ACCESS, pacl); +- posix_acl_release(dpacl); +- posix_acl_release(pacl); ++ if (dentry) { ++ v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, *dpacl); ++ v9fs_set_acl(dentry, ACL_TYPE_ACCESS, *pacl); ++ } ++ posix_acl_release(*dpacl); ++ posix_acl_release(*pacl); ++ *dpacl = *pacl = NULL; + return 0; + } + +@@ -212,11 +215,11 @@ int v9fs_acl_mode(struct inode *dir, mod + struct posix_acl *clone; + + if (S_ISDIR(mode)) +- *dpacl = acl; ++ *dpacl = posix_acl_dup(acl); + clone = posix_acl_clone(acl, GFP_NOFS); +- retval = -ENOMEM; ++ posix_acl_release(acl); + if (!clone) +- goto cleanup; ++ return -ENOMEM; + + retval = posix_acl_create_masq(clone, &mode); + if (retval < 0) { +@@ -225,11 +228,12 @@ int v9fs_acl_mode(struct inode *dir, mod + } + if (retval > 0) + *pacl = clone; ++ else ++ posix_acl_release(clone); + } + *modep = mode; + return 0; + cleanup: +- posix_acl_release(acl); + return retval; + + } +--- a/fs/9p/acl.h ++++ b/fs/9p/acl.h +@@ -19,7 +19,7 @@ extern int v9fs_get_acl(struct inode *, + extern int v9fs_check_acl(struct inode *inode, int mask, unsigned int flags); + extern int v9fs_acl_chmod(struct dentry *); + extern int v9fs_set_create_acl(struct dentry *, +- struct posix_acl *, struct posix_acl *); ++ struct posix_acl **, struct posix_acl **); + extern int v9fs_acl_mode(struct inode *dir, mode_t *modep, + struct posix_acl **dpacl, struct posix_acl **pacl); + #else +@@ -33,8 +33,8 @@ static inline int v9fs_acl_chmod(struct + return 0; + } + static inline int v9fs_set_create_acl(struct dentry *dentry, +- struct posix_acl *dpacl, +- struct posix_acl *pacl) ++ struct posix_acl **dpacl, ++ struct posix_acl **pacl) + { + return 0; + } +--- a/fs/9p/vfs_inode_dotl.c ++++ b/fs/9p/vfs_inode_dotl.c +@@ -287,7 +287,7 @@ v9fs_vfs_create_dotl(struct inode *dir, + goto error; + + /* Now set the ACL based on the default value */ +- v9fs_set_create_acl(dentry, dacl, pacl); ++ v9fs_set_create_acl(dentry, &dacl, &pacl); + + v9inode = V9FS_I(inode); + mutex_lock(&v9inode->v_mutex); +@@ -328,6 +328,7 @@ error: + err_clunk_old_fid: + if (ofid) + p9_client_clunk(ofid); ++ v9fs_set_create_acl(NULL, &dacl, &pacl); + return err; + } + +@@ -421,12 +422,13 @@ static int v9fs_vfs_mkdir_dotl(struct in + d_instantiate(dentry, inode); + } + /* Now set the ACL based on the default value */ +- v9fs_set_create_acl(dentry, dacl, pacl); ++ v9fs_set_create_acl(dentry, &dacl, &pacl); + inc_nlink(dir); + v9fs_invalidate_inode_attr(dir); + error: + if (fid) + p9_client_clunk(fid); ++ v9fs_set_create_acl(NULL, &dacl, &pacl); + return err; + } + +@@ -826,10 +828,11 @@ v9fs_vfs_mknod_dotl(struct inode *dir, s + d_instantiate(dentry, inode); + } + /* Now set the ACL based on the default value */ +- v9fs_set_create_acl(dentry, dacl, pacl); ++ v9fs_set_create_acl(dentry, &dacl, &pacl); + error: + if (fid) + p9_client_clunk(fid); ++ v9fs_set_create_acl(NULL, &dacl, &pacl); + return err; + } + diff --git a/queue-3.0/fix-the-size-of-receive-buffer-packing-onto-virtio-ring.patch b/queue-3.0/fix-the-size-of-receive-buffer-packing-onto-virtio-ring.patch new file mode 100644 index 0000000000..34cf5d7d88 --- /dev/null +++ b/queue-3.0/fix-the-size-of-receive-buffer-packing-onto-virtio-ring.patch @@ -0,0 +1,29 @@ +From 114e6f3a5ede73d5b56e145f04680c61c3dd67c4 Mon Sep 17 00:00:00 2001 +From: jvrao <jvrao@linux.vnet.ibm.com> +Date: Thu, 30 Jun 2011 23:18:39 +0000 +Subject: Fix the size of receive buffer packing onto VirtIO ring. + +From: jvrao <jvrao@linux.vnet.ibm.com> + +commit 114e6f3a5ede73d5b56e145f04680c61c3dd67c4 upstream. + +Signed-off-by: Venkateswararao Jujjuri "<jvrao@linux.vnet.ibm.com> +Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + net/9p/trans_virtio.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/net/9p/trans_virtio.c ++++ b/net/9p/trans_virtio.c +@@ -367,7 +367,7 @@ req_retry_pinned: + in += inp; + } else { + in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata, +- client->msize); ++ req->rc->capacity); + } + + err = virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc); diff --git a/queue-3.0/fs-9p-always-ask-new-inode-in-create.patch b/queue-3.0/fs-9p-always-ask-new-inode-in-create.patch new file mode 100644 index 0000000000..02b1a3cb07 --- /dev/null +++ b/queue-3.0/fs-9p-always-ask-new-inode-in-create.patch @@ -0,0 +1,232 @@ +From ed80fcfac2565fa866d93ba14f0e75de17a8223e Mon Sep 17 00:00:00 2001 +From: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> +Date: Wed, 6 Jul 2011 16:32:31 +0530 +Subject: fs/9p: Always ask new inode in create + +From: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> + +commit ed80fcfac2565fa866d93ba14f0e75de17a8223e upstream. + +This make sure we don't end up reusing the unlinked inode object. +The ideal way is to use inode i_generation. But i_generation is +not available in userspace always. + +Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + fs/9p/v9fs.h | 27 +++++++++++++++++++++++---- + fs/9p/vfs_inode.c | 22 +++++++++++++++++----- + fs/9p/vfs_inode_dotl.c | 30 +++++++++++++++++++++--------- + 3 files changed, 61 insertions(+), 18 deletions(-) + +--- a/fs/9p/v9fs.h ++++ b/fs/9p/v9fs.h +@@ -153,13 +153,13 @@ extern void v9fs_vfs_put_link(struct den + void *p); + extern struct inode *v9fs_inode_from_fid(struct v9fs_session_info *v9ses, + struct p9_fid *fid, +- struct super_block *sb); ++ struct super_block *sb, int new); + extern const struct inode_operations v9fs_dir_inode_operations_dotl; + extern const struct inode_operations v9fs_file_inode_operations_dotl; + extern const struct inode_operations v9fs_symlink_inode_operations_dotl; + extern struct inode *v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses, + struct p9_fid *fid, +- struct super_block *sb); ++ struct super_block *sb, int new); + + /* other default globals */ + #define V9FS_PORT 564 +@@ -201,8 +201,27 @@ v9fs_get_inode_from_fid(struct v9fs_sess + struct super_block *sb) + { + if (v9fs_proto_dotl(v9ses)) +- return v9fs_inode_from_fid_dotl(v9ses, fid, sb); ++ return v9fs_inode_from_fid_dotl(v9ses, fid, sb, 0); + else +- return v9fs_inode_from_fid(v9ses, fid, sb); ++ return v9fs_inode_from_fid(v9ses, fid, sb, 0); + } ++ ++/** ++ * v9fs_get_new_inode_from_fid - Helper routine to populate an inode by ++ * issuing a attribute request ++ * @v9ses: session information ++ * @fid: fid to issue attribute request for ++ * @sb: superblock on which to create inode ++ * ++ */ ++static inline struct inode * ++v9fs_get_new_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid, ++ struct super_block *sb) ++{ ++ if (v9fs_proto_dotl(v9ses)) ++ return v9fs_inode_from_fid_dotl(v9ses, fid, sb, 1); ++ else ++ return v9fs_inode_from_fid(v9ses, fid, sb, 1); ++} ++ + #endif +--- a/fs/9p/vfs_inode.c ++++ b/fs/9p/vfs_inode.c +@@ -454,6 +454,11 @@ static int v9fs_test_inode(struct inode + return 1; + } + ++static int v9fs_test_new_inode(struct inode *inode, void *data) ++{ ++ return 0; ++} ++ + static int v9fs_set_inode(struct inode *inode, void *data) + { + struct v9fs_inode *v9inode = V9FS_I(inode); +@@ -465,15 +470,22 @@ static int v9fs_set_inode(struct inode * + + static struct inode *v9fs_qid_iget(struct super_block *sb, + struct p9_qid *qid, +- struct p9_wstat *st) ++ struct p9_wstat *st, ++ int new) + { + int retval, umode; + unsigned long i_ino; + struct inode *inode; + struct v9fs_session_info *v9ses = sb->s_fs_info; ++ int (*test)(struct inode *, void *); ++ ++ if (new) ++ test = v9fs_test_new_inode; ++ else ++ test = v9fs_test_inode; + + i_ino = v9fs_qid2ino(qid); +- inode = iget5_locked(sb, i_ino, v9fs_test_inode, v9fs_set_inode, st); ++ inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st); + if (!inode) + return ERR_PTR(-ENOMEM); + if (!(inode->i_state & I_NEW)) +@@ -504,7 +516,7 @@ error: + + struct inode * + v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid, +- struct super_block *sb) ++ struct super_block *sb, int new) + { + struct p9_wstat *st; + struct inode *inode = NULL; +@@ -513,7 +525,7 @@ v9fs_inode_from_fid(struct v9fs_session_ + if (IS_ERR(st)) + return ERR_CAST(st); + +- inode = v9fs_qid_iget(sb, &st->qid, st); ++ inode = v9fs_qid_iget(sb, &st->qid, st, new); + p9stat_free(st); + kfree(st); + return inode; +@@ -615,7 +627,7 @@ v9fs_create(struct v9fs_session_info *v9 + } + + /* instantiate inode and assign the unopened fid to the dentry */ +- inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb); ++ inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); + if (IS_ERR(inode)) { + err = PTR_ERR(inode); + P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err); +--- a/fs/9p/vfs_inode_dotl.c ++++ b/fs/9p/vfs_inode_dotl.c +@@ -108,6 +108,12 @@ static int v9fs_test_inode_dotl(struct i + return 1; + } + ++/* Always get a new inode */ ++static int v9fs_test_new_inode_dotl(struct inode *inode, void *data) ++{ ++ return 0; ++} ++ + static int v9fs_set_inode_dotl(struct inode *inode, void *data) + { + struct v9fs_inode *v9inode = V9FS_I(inode); +@@ -121,16 +127,22 @@ static int v9fs_set_inode_dotl(struct in + static struct inode *v9fs_qid_iget_dotl(struct super_block *sb, + struct p9_qid *qid, + struct p9_fid *fid, +- struct p9_stat_dotl *st) ++ struct p9_stat_dotl *st, ++ int new) + { + int retval; + unsigned long i_ino; + struct inode *inode; + struct v9fs_session_info *v9ses = sb->s_fs_info; ++ int (*test)(struct inode *, void *); ++ ++ if (new) ++ test = v9fs_test_new_inode_dotl; ++ else ++ test = v9fs_test_inode_dotl; + + i_ino = v9fs_qid2ino(qid); +- inode = iget5_locked(sb, i_ino, v9fs_test_inode_dotl, +- v9fs_set_inode_dotl, st); ++ inode = iget5_locked(sb, i_ino, test, v9fs_set_inode_dotl, st); + if (!inode) + return ERR_PTR(-ENOMEM); + if (!(inode->i_state & I_NEW)) +@@ -164,7 +176,7 @@ error: + + struct inode * + v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid, +- struct super_block *sb) ++ struct super_block *sb, int new) + { + struct p9_stat_dotl *st; + struct inode *inode = NULL; +@@ -173,7 +185,7 @@ v9fs_inode_from_fid_dotl(struct v9fs_ses + if (IS_ERR(st)) + return ERR_CAST(st); + +- inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st); ++ inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st, new); + kfree(st); + return inode; + } +@@ -263,7 +275,7 @@ v9fs_vfs_create_dotl(struct inode *dir, + fid = NULL; + goto error; + } +- inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb); ++ inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); + if (IS_ERR(inode)) { + err = PTR_ERR(inode); + P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err); +@@ -383,7 +395,7 @@ static int v9fs_vfs_mkdir_dotl(struct in + goto error; + } + +- inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb); ++ inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); + if (IS_ERR(inode)) { + err = PTR_ERR(inode); + P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", +@@ -636,7 +648,7 @@ v9fs_vfs_symlink_dotl(struct inode *dir, + } + + /* instantiate inode and assign the unopened fid to dentry */ +- inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb); ++ inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); + if (IS_ERR(inode)) { + err = PTR_ERR(inode); + P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", +@@ -789,7 +801,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, s + goto error; + } + +- inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb); ++ inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); + if (IS_ERR(inode)) { + err = PTR_ERR(inode); + P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", diff --git a/queue-3.0/fs-9p-fid-is-not-valid-after-a-failed-clunk.patch b/queue-3.0/fs-9p-fid-is-not-valid-after-a-failed-clunk.patch new file mode 100644 index 0000000000..d47a196999 --- /dev/null +++ b/queue-3.0/fs-9p-fid-is-not-valid-after-a-failed-clunk.patch @@ -0,0 +1,35 @@ +From 5034990e28efb2d232ee82443a9edd62defd17ba Mon Sep 17 00:00:00 2001 +From: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> +Date: Mon, 11 Jul 2011 16:40:58 +0000 +Subject: fs/9p: Fid is not valid after a failed clunk. + +From: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> + +commit 5034990e28efb2d232ee82443a9edd62defd17ba upstream. + +free the fid even in case of failed clunk. + +Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + net/9p/client.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +--- a/net/9p/client.c ++++ b/net/9p/client.c +@@ -1250,9 +1250,11 @@ int p9_client_clunk(struct p9_fid *fid) + P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid); + + p9_free_req(clnt, req); +- p9_fid_destroy(fid); +- + error: ++ /* ++ * Fid is not valid even after a failed clunk ++ */ ++ p9_fid_destroy(fid); + return err; + } + EXPORT_SYMBOL(p9_client_clunk); diff --git a/queue-3.0/fs-9p-fix-invalid-mount-options-args.patch b/queue-3.0/fs-9p-fix-invalid-mount-options-args.patch new file mode 100644 index 0000000000..2c1ba2b08e --- /dev/null +++ b/queue-3.0/fs-9p-fix-invalid-mount-options-args.patch @@ -0,0 +1,99 @@ +From a2dd43bb0d7b9ce28f8a39254c25840c0730498e Mon Sep 17 00:00:00 2001 +From: Prem Karat <prem.karat@linux.vnet.ibm.com> +Date: Fri, 6 May 2011 18:24:18 +0530 +Subject: fs/9p: Fix invalid mount options/args + +From: Prem Karat <prem.karat@linux.vnet.ibm.com> + +commit a2dd43bb0d7b9ce28f8a39254c25840c0730498e upstream. + +Without this fix, if any invalid mount options/args are passed while mouting +the 9p fs, no error (-EINVAL) is returned and default arg value is assigned. + +This fix returns -EINVAL when an invalid arguement is found while parsing +mount options. + +Signed-off-by: Prem Karat <prem.karat@linux.vnet.ibm.com> +Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + fs/9p/v9fs.c | 43 ++++++++++++++++++++++++++++++++++--------- + 1 file changed, 34 insertions(+), 9 deletions(-) + +--- a/fs/9p/v9fs.c ++++ b/fs/9p/v9fs.c +@@ -78,6 +78,25 @@ static const match_table_t tokens = { + {Opt_err, NULL} + }; + ++/* Interpret mount options for cache mode */ ++static int get_cache_mode(char *s) ++{ ++ int version = -EINVAL; ++ ++ if (!strcmp(s, "loose")) { ++ version = CACHE_LOOSE; ++ P9_DPRINTK(P9_DEBUG_9P, "Cache mode: loose\n"); ++ } else if (!strcmp(s, "fscache")) { ++ version = CACHE_FSCACHE; ++ P9_DPRINTK(P9_DEBUG_9P, "Cache mode: fscache\n"); ++ } else if (!strcmp(s, "none")) { ++ version = CACHE_NONE; ++ P9_DPRINTK(P9_DEBUG_9P, "Cache mode: none\n"); ++ } else ++ printk(KERN_INFO "9p: Unknown Cache mode %s.\n", s); ++ return version; ++} ++ + /** + * v9fs_parse_options - parse mount options into session structure + * @v9ses: existing v9fs session information +@@ -97,7 +116,7 @@ static int v9fs_parse_options(struct v9f + /* setup defaults */ + v9ses->afid = ~0; + v9ses->debug = 0; +- v9ses->cache = 0; ++ v9ses->cache = CACHE_NONE; + #ifdef CONFIG_9P_FSCACHE + v9ses->cachetag = NULL; + #endif +@@ -171,13 +190,13 @@ static int v9fs_parse_options(struct v9f + "problem allocating copy of cache arg\n"); + goto free_and_return; + } ++ ret = get_cache_mode(s); ++ if (ret == -EINVAL) { ++ kfree(s); ++ goto free_and_return; ++ } + +- if (strcmp(s, "loose") == 0) +- v9ses->cache = CACHE_LOOSE; +- else if (strcmp(s, "fscache") == 0) +- v9ses->cache = CACHE_FSCACHE; +- else +- v9ses->cache = CACHE_NONE; ++ v9ses->cache = ret; + kfree(s); + break; + +@@ -200,9 +219,15 @@ static int v9fs_parse_options(struct v9f + } else { + v9ses->flags |= V9FS_ACCESS_SINGLE; + v9ses->uid = simple_strtoul(s, &e, 10); +- if (*e != '\0') +- v9ses->uid = ~0; ++ if (*e != '\0') { ++ ret = -EINVAL; ++ printk(KERN_INFO "9p: Unknown access " ++ "argument %s.\n", s); ++ kfree(s); ++ goto free_and_return; ++ } + } ++ + kfree(s); + break; + diff --git a/queue-3.0/fs-9p-when-doing-inode-lookup-compare-qid-details-and-inode.patch b/queue-3.0/fs-9p-when-doing-inode-lookup-compare-qid-details-and-inode.patch new file mode 100644 index 0000000000..54522f9ede --- /dev/null +++ b/queue-3.0/fs-9p-when-doing-inode-lookup-compare-qid-details-and-inode.patch @@ -0,0 +1,277 @@ +From fd2421f54423f307ecd31bdebdca6bc317e0c492 Mon Sep 17 00:00:00 2001 +From: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> +Date: Mon, 11 Jul 2011 16:40:59 +0000 +Subject: fs/9p: When doing inode lookup compare qid details and inode + mode bits. + +From: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> + +commit fd2421f54423f307ecd31bdebdca6bc317e0c492 upstream. + +This make sure we don't use wrong inode from the inode hash. The inode number +of the file deleted is reused by the next file system object created +and if we only use inode number for inode hash lookup we could end up +with wrong struct inode. + +Also compare inode generation number. Not all Linux file system provide +st_gen in userspace. So it could be 0; + +Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + fs/9p/cache.c | 20 +++++++++----------- + fs/9p/cache.h | 9 --------- + fs/9p/v9fs.c | 2 +- + fs/9p/v9fs.h | 2 +- + fs/9p/vfs_inode.c | 36 +++++++++++++++++++++++++++++++++--- + fs/9p/vfs_inode_dotl.c | 41 +++++++++++++++++++++++++++++++++++++---- + 6 files changed, 81 insertions(+), 29 deletions(-) + +--- a/fs/9p/cache.c ++++ b/fs/9p/cache.c +@@ -108,11 +108,10 @@ static uint16_t v9fs_cache_inode_get_key + void *buffer, uint16_t bufmax) + { + const struct v9fs_inode *v9inode = cookie_netfs_data; +- memcpy(buffer, &v9inode->fscache_key->path, +- sizeof(v9inode->fscache_key->path)); ++ memcpy(buffer, &v9inode->qid.path, sizeof(v9inode->qid.path)); + P9_DPRINTK(P9_DEBUG_FSC, "inode %p get key %llu", &v9inode->vfs_inode, +- v9inode->fscache_key->path); +- return sizeof(v9inode->fscache_key->path); ++ v9inode->qid.path); ++ return sizeof(v9inode->qid.path); + } + + static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data, +@@ -129,11 +128,10 @@ static uint16_t v9fs_cache_inode_get_aux + void *buffer, uint16_t buflen) + { + const struct v9fs_inode *v9inode = cookie_netfs_data; +- memcpy(buffer, &v9inode->fscache_key->version, +- sizeof(v9inode->fscache_key->version)); ++ memcpy(buffer, &v9inode->qid.version, sizeof(v9inode->qid.version)); + P9_DPRINTK(P9_DEBUG_FSC, "inode %p get aux %u", &v9inode->vfs_inode, +- v9inode->fscache_key->version); +- return sizeof(v9inode->fscache_key->version); ++ v9inode->qid.version); ++ return sizeof(v9inode->qid.version); + } + + static enum +@@ -143,11 +141,11 @@ fscache_checkaux v9fs_cache_inode_check_ + { + const struct v9fs_inode *v9inode = cookie_netfs_data; + +- if (buflen != sizeof(v9inode->fscache_key->version)) ++ if (buflen != sizeof(v9inode->qid.version)) + return FSCACHE_CHECKAUX_OBSOLETE; + +- if (memcmp(buffer, &v9inode->fscache_key->version, +- sizeof(v9inode->fscache_key->version))) ++ if (memcmp(buffer, &v9inode->qid.version, ++ sizeof(v9inode->qid.version))) + return FSCACHE_CHECKAUX_OBSOLETE; + + return FSCACHE_CHECKAUX_OKAY; +--- a/fs/9p/cache.h ++++ b/fs/9p/cache.h +@@ -93,15 +93,6 @@ static inline void v9fs_uncache_page(str + BUG_ON(PageFsCache(page)); + } + +-static inline void v9fs_fscache_set_key(struct inode *inode, +- struct p9_qid *qid) +-{ +- struct v9fs_inode *v9inode = V9FS_I(inode); +- spin_lock(&v9inode->fscache_lock); +- v9inode->fscache_key = qid; +- spin_unlock(&v9inode->fscache_lock); +-} +- + static inline void v9fs_fscache_wait_on_page_write(struct inode *inode, + struct page *page) + { +--- a/fs/9p/v9fs.c ++++ b/fs/9p/v9fs.c +@@ -487,8 +487,8 @@ static void v9fs_inode_init_once(void *f + struct v9fs_inode *v9inode = (struct v9fs_inode *)foo; + #ifdef CONFIG_9P_FSCACHE + v9inode->fscache = NULL; +- v9inode->fscache_key = NULL; + #endif ++ memset(&v9inode->qid, 0, sizeof(v9inode->qid)); + inode_init_once(&v9inode->vfs_inode); + } + +--- a/fs/9p/v9fs.h ++++ b/fs/9p/v9fs.h +@@ -125,8 +125,8 @@ struct v9fs_inode { + #ifdef CONFIG_9P_FSCACHE + spinlock_t fscache_lock; + struct fscache_cookie *fscache; +- struct p9_qid *fscache_key; + #endif ++ struct p9_qid qid; + unsigned int cache_validity; + struct p9_fid *writeback_fid; + struct mutex v_mutex; +--- a/fs/9p/vfs_inode.c ++++ b/fs/9p/vfs_inode.c +@@ -216,7 +216,6 @@ struct inode *v9fs_alloc_inode(struct su + return NULL; + #ifdef CONFIG_9P_FSCACHE + v9inode->fscache = NULL; +- v9inode->fscache_key = NULL; + spin_lock_init(&v9inode->fscache_lock); + #endif + v9inode->writeback_fid = NULL; +@@ -433,6 +432,37 @@ void v9fs_evict_inode(struct inode *inod + } + } + ++static int v9fs_test_inode(struct inode *inode, void *data) ++{ ++ int umode; ++ struct v9fs_inode *v9inode = V9FS_I(inode); ++ struct p9_wstat *st = (struct p9_wstat *)data; ++ struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode); ++ ++ umode = p9mode2unixmode(v9ses, st->mode); ++ /* don't match inode of different type */ ++ if ((inode->i_mode & S_IFMT) != (umode & S_IFMT)) ++ return 0; ++ ++ /* compare qid details */ ++ if (memcmp(&v9inode->qid.version, ++ &st->qid.version, sizeof(v9inode->qid.version))) ++ return 0; ++ ++ if (v9inode->qid.type != st->qid.type) ++ return 0; ++ return 1; ++} ++ ++static int v9fs_set_inode(struct inode *inode, void *data) ++{ ++ struct v9fs_inode *v9inode = V9FS_I(inode); ++ struct p9_wstat *st = (struct p9_wstat *)data; ++ ++ memcpy(&v9inode->qid, &st->qid, sizeof(st->qid)); ++ return 0; ++} ++ + static struct inode *v9fs_qid_iget(struct super_block *sb, + struct p9_qid *qid, + struct p9_wstat *st) +@@ -443,7 +473,7 @@ static struct inode *v9fs_qid_iget(struc + struct v9fs_session_info *v9ses = sb->s_fs_info; + + i_ino = v9fs_qid2ino(qid); +- inode = iget_locked(sb, i_ino); ++ inode = iget5_locked(sb, i_ino, v9fs_test_inode, v9fs_set_inode, st); + if (!inode) + return ERR_PTR(-ENOMEM); + if (!(inode->i_state & I_NEW)) +@@ -453,6 +483,7 @@ static struct inode *v9fs_qid_iget(struc + * FIXME!! we may need support for stale inodes + * later. + */ ++ inode->i_ino = i_ino; + umode = p9mode2unixmode(v9ses, st->mode); + retval = v9fs_init_inode(v9ses, inode, umode); + if (retval) +@@ -460,7 +491,6 @@ static struct inode *v9fs_qid_iget(struc + + v9fs_stat2inode(st, inode, sb); + #ifdef CONFIG_9P_FSCACHE +- v9fs_fscache_set_key(inode, &st->qid); + v9fs_cache_inode_get_cookie(inode); + #endif + unlock_new_inode(inode); +--- a/fs/9p/vfs_inode_dotl.c ++++ b/fs/9p/vfs_inode_dotl.c +@@ -86,6 +86,38 @@ static struct dentry *v9fs_dentry_from_d + return dentry; + } + ++static int v9fs_test_inode_dotl(struct inode *inode, void *data) ++{ ++ struct v9fs_inode *v9inode = V9FS_I(inode); ++ struct p9_stat_dotl *st = (struct p9_stat_dotl *)data; ++ ++ /* don't match inode of different type */ ++ if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT)) ++ return 0; ++ ++ if (inode->i_generation != st->st_gen) ++ return 0; ++ ++ /* compare qid details */ ++ if (memcmp(&v9inode->qid.version, ++ &st->qid.version, sizeof(v9inode->qid.version))) ++ return 0; ++ ++ if (v9inode->qid.type != st->qid.type) ++ return 0; ++ return 1; ++} ++ ++static int v9fs_set_inode_dotl(struct inode *inode, void *data) ++{ ++ struct v9fs_inode *v9inode = V9FS_I(inode); ++ struct p9_stat_dotl *st = (struct p9_stat_dotl *)data; ++ ++ memcpy(&v9inode->qid, &st->qid, sizeof(st->qid)); ++ inode->i_generation = st->st_gen; ++ return 0; ++} ++ + static struct inode *v9fs_qid_iget_dotl(struct super_block *sb, + struct p9_qid *qid, + struct p9_fid *fid, +@@ -97,7 +129,8 @@ static struct inode *v9fs_qid_iget_dotl( + struct v9fs_session_info *v9ses = sb->s_fs_info; + + i_ino = v9fs_qid2ino(qid); +- inode = iget_locked(sb, i_ino); ++ inode = iget5_locked(sb, i_ino, v9fs_test_inode_dotl, ++ v9fs_set_inode_dotl, st); + if (!inode) + return ERR_PTR(-ENOMEM); + if (!(inode->i_state & I_NEW)) +@@ -107,13 +140,13 @@ static struct inode *v9fs_qid_iget_dotl( + * FIXME!! we may need support for stale inodes + * later. + */ ++ inode->i_ino = i_ino; + retval = v9fs_init_inode(v9ses, inode, st->st_mode); + if (retval) + goto error; + + v9fs_stat2inode_dotl(st, inode); + #ifdef CONFIG_9P_FSCACHE +- v9fs_fscache_set_key(inode, &st->qid); + v9fs_cache_inode_get_cookie(inode); + #endif + retval = v9fs_get_acl(inode, fid); +@@ -136,7 +169,7 @@ v9fs_inode_from_fid_dotl(struct v9fs_ses + struct p9_stat_dotl *st; + struct inode *inode = NULL; + +- st = p9_client_getattr_dotl(fid, P9_STATS_BASIC); ++ st = p9_client_getattr_dotl(fid, P9_STATS_BASIC | P9_STATS_GEN); + if (IS_ERR(st)) + return ERR_CAST(st); + +@@ -547,7 +580,7 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl + inode->i_blocks = stat->st_blocks; + } + if (stat->st_result_mask & P9_STATS_GEN) +- inode->i_generation = stat->st_gen; ++ inode->i_generation = stat->st_gen; + + /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION + * because the inode structure does not have fields for them. diff --git a/queue-3.0/iommu-amd-don-t-take-domain-lock-recursivly.patch b/queue-3.0/iommu-amd-don-t-take-domain-lock-recursivly.patch new file mode 100644 index 0000000000..fecd248fa1 --- /dev/null +++ b/queue-3.0/iommu-amd-don-t-take-domain-lock-recursivly.patch @@ -0,0 +1,39 @@ +From e33acde91140f1809952d1c135c36feb66a51887 Mon Sep 17 00:00:00 2001 +From: Joerg Roedel <joerg.roedel@amd.com> +Date: Fri, 2 Sep 2011 14:19:50 +0200 +Subject: iommu/amd: Don't take domain->lock recursivly + +From: Joerg Roedel <joerg.roedel@amd.com> + +commit e33acde91140f1809952d1c135c36feb66a51887 upstream. + +The domain_flush_devices() function takes the domain->lock. +But this function is only called from update_domain() which +itself is already called unter the domain->lock. This causes +a deadlock situation when the dma-address-space of a domain +grows larger than 1GB. + +Signed-off-by: Joerg Roedel <joerg.roedel@amd.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + arch/x86/kernel/amd_iommu.c | 5 ----- + 1 file changed, 5 deletions(-) + +--- a/arch/x86/kernel/amd_iommu.c ++++ b/arch/x86/kernel/amd_iommu.c +@@ -773,14 +773,9 @@ static void domain_flush_complete(struct + static void domain_flush_devices(struct protection_domain *domain) + { + struct iommu_dev_data *dev_data; +- unsigned long flags; +- +- spin_lock_irqsave(&domain->lock, flags); + + list_for_each_entry(dev_data, &domain->dev_list, list) + device_flush_dte(dev_data->dev); +- +- spin_unlock_irqrestore(&domain->lock, flags); + } + + /**************************************************************************** diff --git a/queue-3.0/iommu-amd-make-sure-iommu-need_sync-contains-correct-value.patch b/queue-3.0/iommu-amd-make-sure-iommu-need_sync-contains-correct-value.patch new file mode 100644 index 0000000000..d7387a6b5c --- /dev/null +++ b/queue-3.0/iommu-amd-make-sure-iommu-need_sync-contains-correct-value.patch @@ -0,0 +1,62 @@ +From f1ca1512e765337a7c09eb875eedef8ea4e07654 Mon Sep 17 00:00:00 2001 +From: Joerg Roedel <joerg.roedel@amd.com> +Date: Fri, 2 Sep 2011 14:10:32 +0200 +Subject: iommu/amd: Make sure iommu->need_sync contains correct value + +From: Joerg Roedel <joerg.roedel@amd.com> + +commit f1ca1512e765337a7c09eb875eedef8ea4e07654 upstream. + +The value is only set to true but never set back to false, +which causes to many completion-wait commands to be sent to +hardware. Fix it with this patch. + +Signed-off-by: Joerg Roedel <joerg.roedel@amd.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + arch/x86/kernel/amd_iommu.c | 13 ++++++++++--- + 1 file changed, 10 insertions(+), 3 deletions(-) + +--- a/arch/x86/kernel/amd_iommu.c ++++ b/arch/x86/kernel/amd_iommu.c +@@ -531,7 +531,9 @@ static void build_inv_all(struct iommu_c + * Writes the command to the IOMMUs command buffer and informs the + * hardware about the new command. + */ +-static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd) ++static int iommu_queue_command_sync(struct amd_iommu *iommu, ++ struct iommu_cmd *cmd, ++ bool sync) + { + u32 left, tail, head, next_tail; + unsigned long flags; +@@ -565,13 +567,18 @@ again: + copy_cmd_to_buffer(iommu, cmd, tail); + + /* We need to sync now to make sure all commands are processed */ +- iommu->need_sync = true; ++ iommu->need_sync = sync; + + spin_unlock_irqrestore(&iommu->lock, flags); + + return 0; + } + ++static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd) ++{ ++ return iommu_queue_command_sync(iommu, cmd, true); ++} ++ + /* + * This function queues a completion wait command into the command + * buffer of an IOMMU +@@ -587,7 +594,7 @@ static int iommu_completion_wait(struct + + build_completion_wait(&cmd, (u64)&sem); + +- ret = iommu_queue_command(iommu, &cmd); ++ ret = iommu_queue_command_sync(iommu, &cmd, false); + if (ret) + return ret; + diff --git a/queue-3.0/irda-fix-smsc-ircc2-section-mismatch-warning.patch b/queue-3.0/irda-fix-smsc-ircc2-section-mismatch-warning.patch new file mode 100644 index 0000000000..db2cdfe7e3 --- /dev/null +++ b/queue-3.0/irda-fix-smsc-ircc2-section-mismatch-warning.patch @@ -0,0 +1,32 @@ +From f470e5ae34d68880a38aa79ee5c102ebc2a1aef6 Mon Sep 17 00:00:00 2001 +From: Randy Dunlap <randy.dunlap@oracle.com> +Date: Tue, 21 Jun 2011 20:32:53 -0700 +Subject: irda: fix smsc-ircc2 section mismatch warning + +From: Randy Dunlap <randy.dunlap@oracle.com> + +commit f470e5ae34d68880a38aa79ee5c102ebc2a1aef6 upstream. + +Fix section mismatch warning: + +WARNING: drivers/net/irda/smsc-ircc2.o(.devinit.text+0x1a7): Section mismatch in reference from the function smsc_ircc_pnp_probe() to the function .init.text:smsc_ircc_open() + +Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com> +Signed-off-by: David S. Miller <davem@davemloft.net> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + drivers/net/irda/smsc-ircc2.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/net/irda/smsc-ircc2.c ++++ b/drivers/net/irda/smsc-ircc2.c +@@ -515,7 +515,7 @@ static const struct net_device_ops smsc_ + * Try to open driver instance + * + */ +-static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u8 dma, u8 irq) ++static int __devinit smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u8 dma, u8 irq) + { + struct smsc_ircc_cb *self; + struct net_device *dev; diff --git a/queue-3.0/net-9p-fix-client-code-to-fail-more-gracefully-on-protocol-error.patch b/queue-3.0/net-9p-fix-client-code-to-fail-more-gracefully-on-protocol-error.patch new file mode 100644 index 0000000000..458a332867 --- /dev/null +++ b/queue-3.0/net-9p-fix-client-code-to-fail-more-gracefully-on-protocol-error.patch @@ -0,0 +1,32 @@ +From b85f7d92d7bd7e3298159e8b1eed8cb8cbbb0348 Mon Sep 17 00:00:00 2001 +From: Eric Van Hensbergen <ericvh@gmail.com> +Date: Wed, 13 Jul 2011 19:12:18 -0500 +Subject: net/9p: fix client code to fail more gracefully on protocol error + +From: Eric Van Hensbergen <ericvh@gmail.com> + +commit b85f7d92d7bd7e3298159e8b1eed8cb8cbbb0348 upstream. + +There was a BUG_ON to protect against a bad id which could be dealt with +more gracefully. + +Reported-by: Natalie Orlin <norlin@us.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + net/9p/client.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +--- a/net/9p/client.c ++++ b/net/9p/client.c +@@ -280,7 +280,8 @@ struct p9_req_t *p9_tag_lookup(struct p9 + * buffer to read the data into */ + tag++; + +- BUG_ON(tag >= c->max_tag); ++ if(tag >= c->max_tag) ++ return NULL; + + row = tag / P9_ROW_MAXTAG; + col = tag % P9_ROW_MAXTAG; diff --git a/queue-3.0/net-9p-fix-the-msize-calculation.patch b/queue-3.0/net-9p-fix-the-msize-calculation.patch new file mode 100644 index 0000000000..71b3d0c3ba --- /dev/null +++ b/queue-3.0/net-9p-fix-the-msize-calculation.patch @@ -0,0 +1,33 @@ +From c9ffb05ca5b5098d6ea468c909dd384d90da7d54 Mon Sep 17 00:00:00 2001 +From: "Venkateswararao Jujjuri (JV)" <jvrao@linux.vnet.ibm.com> +Date: Wed, 29 Jun 2011 18:06:33 -0700 +Subject: net/9p: Fix the msize calculation. + +From: "Venkateswararao Jujjuri (JV)" <jvrao@linux.vnet.ibm.com> + +commit c9ffb05ca5b5098d6ea468c909dd384d90da7d54 upstream. + +msize represents the maximum PDU size that includes P9_IOHDRSZ. + +Signed-off-by: Venkateswararao Jujjuri "<jvrao@linux.vnet.ibm.com> +Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + net/9p/client.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/net/9p/client.c ++++ b/net/9p/client.c +@@ -822,8 +822,8 @@ struct p9_client *p9_client_create(const + if (err) + goto destroy_fidpool; + +- if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize) +- clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ; ++ if (clnt->msize > clnt->trans_mod->maxsize) ++ clnt->msize = clnt->trans_mod->maxsize; + + err = p9_client_version(clnt); + if (err) diff --git a/queue-3.0/series b/queue-3.0/series index 93d2953e34..334ea59fc6 100644 --- a/queue-3.0/series +++ b/queue-3.0/series @@ -77,3 +77,15 @@ avoid-dereferencing-a-request_queue-after-last-close.patch md-fix-handling-for-devices-from-2tb-to-4tb-in-0.90.patch nuvoton-cir-simplify-raw-ir-sample-handling.patch vp7045-fix-buffer-setup.patch +net-9p-fix-client-code-to-fail-more-gracefully-on-protocol-error.patch +fix-the-size-of-receive-buffer-packing-onto-virtio-ring.patch +virtio-can-transfer-virtqueue_num-of-pages.patch +fs-9p-fid-is-not-valid-after-a-failed-clunk.patch +fs-9p-when-doing-inode-lookup-compare-qid-details-and-inode.patch +fs-9p-fix-invalid-mount-options-args.patch +fs-9p-always-ask-new-inode-in-create.patch +net-9p-fix-the-msize-calculation.patch +9p-close-acl-leaks.patch +irda-fix-smsc-ircc2-section-mismatch-warning.patch +iommu-amd-don-t-take-domain-lock-recursivly.patch +iommu-amd-make-sure-iommu-need_sync-contains-correct-value.patch diff --git a/queue-3.0/virtio-can-transfer-virtqueue_num-of-pages.patch b/queue-3.0/virtio-can-transfer-virtqueue_num-of-pages.patch new file mode 100644 index 0000000000..6ecf8fdb17 --- /dev/null +++ b/queue-3.0/virtio-can-transfer-virtqueue_num-of-pages.patch @@ -0,0 +1,29 @@ +From 7f781679dd596c8abde8336b4d0d166d6a4aad04 Mon Sep 17 00:00:00 2001 +From: jvrao <jvrao@linux.vnet.ibm.com> +Date: Thu, 30 Jun 2011 23:18:41 +0000 +Subject: VirtIO can transfer VIRTQUEUE_NUM of pages. + +From: jvrao <jvrao@linux.vnet.ibm.com> + +commit 7f781679dd596c8abde8336b4d0d166d6a4aad04 upstream. + +Signed-off-by: Venkateswararao Jujjuri "<jvrao@linux.vnet.ibm.com> +Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> +Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + net/9p/trans_virtio.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/net/9p/trans_virtio.c ++++ b/net/9p/trans_virtio.c +@@ -592,7 +592,7 @@ static struct p9_trans_module p9_virtio_ + .close = p9_virtio_close, + .request = p9_virtio_request, + .cancel = p9_virtio_cancel, +- .maxsize = PAGE_SIZE*16, ++ .maxsize = PAGE_SIZE*VIRTQUEUE_NUM, + .pref = P9_TRANS_PREF_PAYLOAD_SEP, + .def = 0, + .owner = THIS_MODULE, |