2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License v.2.
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/vmalloc.h>
16 #include <linux/blkdev.h>
17 #include <linux/kthread.h>
18 #include <asm/semaphore.h>
27 #include "ops_export.h"
28 #include "ops_fstype.h"
29 #include "ops_super.h"
39 static struct gfs2_sbd
*init_sbd(struct super_block
*sb
)
44 sdp
= vmalloc(sizeof(struct gfs2_sbd
));
48 memset(sdp
, 0, sizeof(struct gfs2_sbd
));
53 gfs2_tune_init(&sdp
->sd_tune
);
55 for (x
= 0; x
< GFS2_GL_HASH_SIZE
; x
++) {
56 sdp
->sd_gl_hash
[x
].hb_lock
= RW_LOCK_UNLOCKED
;
57 INIT_LIST_HEAD(&sdp
->sd_gl_hash
[x
].hb_list
);
59 INIT_LIST_HEAD(&sdp
->sd_reclaim_list
);
60 spin_lock_init(&sdp
->sd_reclaim_lock
);
61 init_waitqueue_head(&sdp
->sd_reclaim_wq
);
62 mutex_init(&sdp
->sd_invalidate_inodes_mutex
);
64 mutex_init(&sdp
->sd_inum_mutex
);
65 spin_lock_init(&sdp
->sd_statfs_spin
);
66 mutex_init(&sdp
->sd_statfs_mutex
);
68 spin_lock_init(&sdp
->sd_rindex_spin
);
69 mutex_init(&sdp
->sd_rindex_mutex
);
70 INIT_LIST_HEAD(&sdp
->sd_rindex_list
);
71 INIT_LIST_HEAD(&sdp
->sd_rindex_mru_list
);
72 INIT_LIST_HEAD(&sdp
->sd_rindex_recent_list
);
74 INIT_LIST_HEAD(&sdp
->sd_jindex_list
);
75 spin_lock_init(&sdp
->sd_jindex_spin
);
76 mutex_init(&sdp
->sd_jindex_mutex
);
78 INIT_LIST_HEAD(&sdp
->sd_unlinked_list
);
79 spin_lock_init(&sdp
->sd_unlinked_spin
);
80 mutex_init(&sdp
->sd_unlinked_mutex
);
82 INIT_LIST_HEAD(&sdp
->sd_quota_list
);
83 spin_lock_init(&sdp
->sd_quota_spin
);
84 mutex_init(&sdp
->sd_quota_mutex
);
86 spin_lock_init(&sdp
->sd_log_lock
);
87 init_waitqueue_head(&sdp
->sd_log_trans_wq
);
88 init_waitqueue_head(&sdp
->sd_log_flush_wq
);
90 INIT_LIST_HEAD(&sdp
->sd_log_le_gl
);
91 INIT_LIST_HEAD(&sdp
->sd_log_le_buf
);
92 INIT_LIST_HEAD(&sdp
->sd_log_le_revoke
);
93 INIT_LIST_HEAD(&sdp
->sd_log_le_rg
);
94 INIT_LIST_HEAD(&sdp
->sd_log_le_databuf
);
96 INIT_LIST_HEAD(&sdp
->sd_log_blks_list
);
97 init_waitqueue_head(&sdp
->sd_log_blks_wait
);
99 INIT_LIST_HEAD(&sdp
->sd_ail1_list
);
100 INIT_LIST_HEAD(&sdp
->sd_ail2_list
);
102 mutex_init(&sdp
->sd_log_flush_lock
);
103 INIT_LIST_HEAD(&sdp
->sd_log_flush_list
);
105 INIT_LIST_HEAD(&sdp
->sd_revoke_list
);
107 mutex_init(&sdp
->sd_freeze_lock
);
112 static void init_vfs(struct gfs2_sbd
*sdp
)
114 struct super_block
*sb
= sdp
->sd_vfs
;
116 sb
->s_magic
= GFS2_MAGIC
;
117 sb
->s_op
= &gfs2_super_ops
;
118 sb
->s_export_op
= &gfs2_export_ops
;
119 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
121 if (sb
->s_flags
& (MS_NOATIME
| MS_NODIRATIME
))
122 set_bit(SDF_NOATIME
, &sdp
->sd_flags
);
124 /* Don't let the VFS update atimes. GFS2 handles this itself. */
125 sb
->s_flags
|= MS_NOATIME
| MS_NODIRATIME
;
127 /* Set up the buffer cache and fill in some fake block size values
128 to allow us to read-in the on-disk superblock. */
129 sdp
->sd_sb
.sb_bsize
= sb_min_blocksize(sb
, GFS2_BASIC_BLOCK
);
130 sdp
->sd_sb
.sb_bsize_shift
= sb
->s_blocksize_bits
;
131 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
132 GFS2_BASIC_BLOCK_SHIFT
;
133 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
136 static int init_names(struct gfs2_sbd
*sdp
, int silent
)
138 struct gfs2_sb
*sb
= NULL
;
142 proto
= sdp
->sd_args
.ar_lockproto
;
143 table
= sdp
->sd_args
.ar_locktable
;
145 /* Try to autodetect */
147 if (!proto
[0] || !table
[0]) {
148 struct buffer_head
*bh
;
149 bh
= sb_getblk(sdp
->sd_vfs
,
150 GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
152 clear_buffer_uptodate(bh
);
153 clear_buffer_dirty(bh
);
155 ll_rw_block(READ
, 1, &bh
);
158 if (!buffer_uptodate(bh
)) {
163 sb
= kmalloc(sizeof(struct gfs2_sb
), GFP_KERNEL
);
168 gfs2_sb_in(sb
, bh
->b_data
);
171 error
= gfs2_check_sb(sdp
, sb
, silent
);
176 proto
= sb
->sb_lockproto
;
178 table
= sb
->sb_locktable
;
182 table
= sdp
->sd_vfs
->s_id
;
184 snprintf(sdp
->sd_proto_name
, GFS2_FSNAME_LEN
, "%s", proto
);
185 snprintf(sdp
->sd_table_name
, GFS2_FSNAME_LEN
, "%s", table
);
193 static int init_locking(struct gfs2_sbd
*sdp
, struct gfs2_holder
*mount_gh
,
196 struct task_struct
*p
;
202 p
= kthread_run(gfs2_scand
, sdp
, "gfs2_scand");
205 fs_err(sdp
, "can't start scand thread: %d\n", error
);
208 sdp
->sd_scand_process
= p
;
210 for (sdp
->sd_glockd_num
= 0;
211 sdp
->sd_glockd_num
< sdp
->sd_args
.ar_num_glockd
;
212 sdp
->sd_glockd_num
++) {
213 p
= kthread_run(gfs2_glockd
, sdp
, "gfs2_glockd");
216 fs_err(sdp
, "can't start glockd thread: %d\n", error
);
219 sdp
->sd_glockd_process
[sdp
->sd_glockd_num
] = p
;
222 error
= gfs2_glock_nq_num(sdp
,
223 GFS2_MOUNT_LOCK
, &gfs2_nondisk_glops
,
224 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
| GL_NOCACHE
,
227 fs_err(sdp
, "can't acquire mount glock: %d\n", error
);
231 error
= gfs2_glock_nq_num(sdp
,
232 GFS2_LIVE_LOCK
, &gfs2_nondisk_glops
,
234 LM_FLAG_NOEXP
| GL_EXACT
| GL_NEVER_RECURSE
,
237 fs_err(sdp
, "can't acquire live glock: %d\n", error
);
241 error
= gfs2_glock_get(sdp
, GFS2_RENAME_LOCK
, &gfs2_nondisk_glops
,
242 CREATE
, &sdp
->sd_rename_gl
);
244 fs_err(sdp
, "can't create rename glock: %d\n", error
);
248 error
= gfs2_glock_get(sdp
, GFS2_TRANS_LOCK
, &gfs2_trans_glops
,
249 CREATE
, &sdp
->sd_trans_gl
);
251 fs_err(sdp
, "can't create transaction glock: %d\n", error
);
254 set_bit(GLF_STICKY
, &sdp
->sd_trans_gl
->gl_flags
);
259 gfs2_glock_put(sdp
->sd_trans_gl
);
262 gfs2_glock_put(sdp
->sd_rename_gl
);
265 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
268 gfs2_glock_dq_uninit(mount_gh
);
271 while (sdp
->sd_glockd_num
--)
272 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
274 kthread_stop(sdp
->sd_scand_process
);
279 int gfs2_lookup_root(struct gfs2_sbd
*sdp
)
282 struct gfs2_glock
*gl
;
283 struct gfs2_inode
*ip
;
285 error
= gfs2_glock_get(sdp
, sdp
->sd_sb
.sb_root_dir
.no_addr
,
286 &gfs2_inode_glops
, CREATE
, &gl
);
288 error
= gfs2_inode_get(gl
, &sdp
->sd_sb
.sb_root_dir
,
292 gfs2_inode_min_init(ip
, DT_DIR
);
293 sdp
->sd_root_dir
= gfs2_ip2v(ip
);
302 static int init_sb(struct gfs2_sbd
*sdp
, int silent
, int undo
)
304 struct super_block
*sb
= sdp
->sd_vfs
;
305 struct gfs2_holder sb_gh
;
310 iput(sdp
->sd_master_dir
);
314 error
= gfs2_glock_nq_num(sdp
,
315 GFS2_SB_LOCK
, &gfs2_meta_glops
,
316 LM_ST_SHARED
, 0, &sb_gh
);
318 fs_err(sdp
, "can't acquire superblock glock: %d\n", error
);
322 error
= gfs2_read_sb(sdp
, sb_gh
.gh_gl
, silent
);
324 fs_err(sdp
, "can't read superblock: %d\n", error
);
328 /* Set up the buffer cache and SB for real */
330 if (sdp
->sd_sb
.sb_bsize
< bdev_hardsect_size(sb
->s_bdev
)) {
331 fs_err(sdp
, "FS block size (%u) is too small for device "
333 sdp
->sd_sb
.sb_bsize
, bdev_hardsect_size(sb
->s_bdev
));
336 if (sdp
->sd_sb
.sb_bsize
> PAGE_SIZE
) {
337 fs_err(sdp
, "FS block size (%u) is too big for machine "
339 sdp
->sd_sb
.sb_bsize
, (unsigned int)PAGE_SIZE
);
343 /* Get rid of buffers from the original block size */
344 sb_gh
.gh_gl
->gl_ops
->go_inval(sb_gh
.gh_gl
, DIO_METADATA
| DIO_DATA
);
345 sb_gh
.gh_gl
->gl_aspace
->i_blkbits
= sdp
->sd_sb
.sb_bsize_shift
;
347 sb_set_blocksize(sb
, sdp
->sd_sb
.sb_bsize
);
349 /* Get the root inode */
350 error
= gfs2_lookup_root(sdp
);
352 fs_err(sdp
, "can't read in root inode: %d\n", error
);
356 /* Get the root inode/dentry */
357 inode
= sdp
->sd_root_dir
;
359 fs_err(sdp
, "can't get root inode\n");
365 sb
->s_root
= d_alloc_root(inode
);
367 fs_err(sdp
, "can't get root dentry\n");
373 gfs2_glock_dq_uninit(&sb_gh
);
377 iput(sdp
->sd_root_dir
);
381 static int init_journal(struct gfs2_sbd
*sdp
, int undo
)
383 struct gfs2_holder ji_gh
;
384 struct task_struct
*p
;
393 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "jindex",
396 fs_err(sdp
, "can't lookup journal index: %d\n", error
);
399 set_bit(GLF_STICKY
, &get_v2ip(sdp
->sd_jindex
)->i_gl
->gl_flags
);
401 /* Load in the journal index special file */
403 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
405 fs_err(sdp
, "can't read journal index: %d\n", error
);
410 if (!gfs2_jindex_size(sdp
)) {
411 fs_err(sdp
, "no journals!\n");
415 if (sdp
->sd_args
.ar_spectator
) {
416 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, 0);
417 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
419 if (sdp
->sd_lockstruct
.ls_jid
>= gfs2_jindex_size(sdp
)) {
420 fs_err(sdp
, "can't mount journal #%u\n",
421 sdp
->sd_lockstruct
.ls_jid
);
422 fs_err(sdp
, "there are only %u journals (0 - %u)\n",
423 gfs2_jindex_size(sdp
),
424 gfs2_jindex_size(sdp
) - 1);
427 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, sdp
->sd_lockstruct
.ls_jid
);
429 error
= gfs2_glock_nq_num(sdp
,
430 sdp
->sd_lockstruct
.ls_jid
,
432 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
,
433 &sdp
->sd_journal_gh
);
435 fs_err(sdp
, "can't acquire journal glock: %d\n", error
);
439 error
= gfs2_glock_nq_init(
440 get_v2ip(sdp
->sd_jdesc
->jd_inode
)->i_gl
,
442 LM_FLAG_NOEXP
| GL_EXACT
,
445 fs_err(sdp
, "can't acquire journal inode glock: %d\n",
447 goto fail_journal_gh
;
450 error
= gfs2_jdesc_check(sdp
->sd_jdesc
);
452 fs_err(sdp
, "my journal (%u) is bad: %d\n",
453 sdp
->sd_jdesc
->jd_jid
, error
);
456 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
459 if (sdp
->sd_lockstruct
.ls_first
) {
461 for (x
= 0; x
< sdp
->sd_journals
; x
++) {
462 error
= gfs2_recover_journal(gfs2_jdesc_find(sdp
, x
),
465 fs_err(sdp
, "error recovering journal %u: %d\n",
471 gfs2_lm_others_may_mount(sdp
);
472 } else if (!sdp
->sd_args
.ar_spectator
) {
473 error
= gfs2_recover_journal(sdp
->sd_jdesc
, WAIT
);
475 fs_err(sdp
, "error recovering my journal: %d\n", error
);
480 set_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
);
481 gfs2_glock_dq_uninit(&ji_gh
);
484 /* Disown my Journal glock */
486 sdp
->sd_journal_gh
.gh_owner
= NULL
;
487 sdp
->sd_jinode_gh
.gh_owner
= NULL
;
489 p
= kthread_run(gfs2_recoverd
, sdp
, "gfs2_recoverd");
492 fs_err(sdp
, "can't start recoverd thread: %d\n", error
);
495 sdp
->sd_recoverd_process
= p
;
500 kthread_stop(sdp
->sd_recoverd_process
);
503 if (!sdp
->sd_args
.ar_spectator
)
504 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
507 if (!sdp
->sd_args
.ar_spectator
)
508 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
511 gfs2_jindex_free(sdp
);
513 gfs2_glock_dq_uninit(&ji_gh
);
516 iput(sdp
->sd_jindex
);
522 static int init_inodes(struct gfs2_sbd
*sdp
, int undo
)
529 error
= gfs2_lookup_master_dir(sdp
);
531 fs_err(sdp
, "can't read in master directory: %d\n", error
);
535 error
= init_journal(sdp
, undo
);
539 /* Read in the master inode number inode */
540 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "inum",
541 &sdp
->sd_inum_inode
);
543 fs_err(sdp
, "can't read in inum inode: %d\n", error
);
548 /* Read in the master statfs inode */
549 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "statfs",
550 &sdp
->sd_statfs_inode
);
552 fs_err(sdp
, "can't read in statfs inode: %d\n", error
);
556 /* Read in the resource index inode */
557 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "rindex",
560 fs_err(sdp
, "can't get resource index inode: %d\n", error
);
563 set_bit(GLF_STICKY
, &get_v2ip(sdp
->sd_rindex
)->i_gl
->gl_flags
);
564 sdp
->sd_rindex_vn
= get_v2ip(sdp
->sd_rindex
)->i_gl
->gl_vn
- 1;
566 /* Read in the quota inode */
567 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "quota",
568 &sdp
->sd_quota_inode
);
570 fs_err(sdp
, "can't get quota file inode: %d\n", error
);
576 iput(sdp
->sd_quota_inode
);
579 gfs2_clear_rgrpd(sdp
);
580 iput(sdp
->sd_rindex
);
583 iput(sdp
->sd_statfs_inode
);
586 iput(sdp
->sd_inum_inode
);
588 init_journal(sdp
, UNDO
);
590 iput(sdp
->sd_master_dir
);
595 static int init_per_node(struct gfs2_sbd
*sdp
, int undo
)
597 struct inode
*pn
= NULL
;
601 if (sdp
->sd_args
.ar_spectator
)
607 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "per_node", &pn
);
609 fs_err(sdp
, "can't find per_node directory: %d\n", error
);
613 sprintf(buf
, "inum_range%u", sdp
->sd_jdesc
->jd_jid
);
614 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_ir_inode
);
616 fs_err(sdp
, "can't find local \"ir\" file: %d\n", error
);
620 sprintf(buf
, "statfs_change%u", sdp
->sd_jdesc
->jd_jid
);
621 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_sc_inode
);
623 fs_err(sdp
, "can't find local \"sc\" file: %d\n", error
);
627 sprintf(buf
, "unlinked_tag%u", sdp
->sd_jdesc
->jd_jid
);
628 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_ut_inode
);
630 fs_err(sdp
, "can't find local \"ut\" file: %d\n", error
);
634 sprintf(buf
, "quota_change%u", sdp
->sd_jdesc
->jd_jid
);
635 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_qc_inode
);
637 fs_err(sdp
, "can't find local \"qc\" file: %d\n", error
);
644 error
= gfs2_glock_nq_init(get_v2ip(sdp
->sd_ir_inode
)->i_gl
,
645 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
648 fs_err(sdp
, "can't lock local \"ir\" file: %d\n", error
);
652 error
= gfs2_glock_nq_init(get_v2ip(sdp
->sd_sc_inode
)->i_gl
,
653 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
656 fs_err(sdp
, "can't lock local \"sc\" file: %d\n", error
);
660 error
= gfs2_glock_nq_init(get_v2ip(sdp
->sd_ut_inode
)->i_gl
,
661 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
664 fs_err(sdp
, "can't lock local \"ut\" file: %d\n", error
);
668 error
= gfs2_glock_nq_init(get_v2ip(sdp
->sd_qc_inode
)->i_gl
,
669 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
672 fs_err(sdp
, "can't lock local \"qc\" file: %d\n", error
);
679 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
682 gfs2_glock_dq_uninit(&sdp
->sd_ut_gh
);
685 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
688 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
691 iput(sdp
->sd_qc_inode
);
694 iput(sdp
->sd_ut_inode
);
697 iput(sdp
->sd_sc_inode
);
700 iput(sdp
->sd_ir_inode
);
708 static int init_threads(struct gfs2_sbd
*sdp
, int undo
)
710 struct task_struct
*p
;
716 sdp
->sd_log_flush_time
= jiffies
;
717 sdp
->sd_jindex_refresh_time
= jiffies
;
719 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
722 fs_err(sdp
, "can't start logd thread: %d\n", error
);
725 sdp
->sd_logd_process
= p
;
727 sdp
->sd_statfs_sync_time
= jiffies
;
728 sdp
->sd_quota_sync_time
= jiffies
;
730 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
733 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
736 sdp
->sd_quotad_process
= p
;
738 p
= kthread_run(gfs2_inoded
, sdp
, "gfs2_inoded");
741 fs_err(sdp
, "can't start inoded thread: %d\n", error
);
744 sdp
->sd_inoded_process
= p
;
749 kthread_stop(sdp
->sd_inoded_process
);
752 kthread_stop(sdp
->sd_quotad_process
);
755 kthread_stop(sdp
->sd_logd_process
);
761 * fill_super - Read in superblock
762 * @sb: The VFS superblock
763 * @data: Mount options
764 * @silent: Don't complain if it's not a GFS2 filesystem
769 static int fill_super(struct super_block
*sb
, void *data
, int silent
)
771 struct gfs2_sbd
*sdp
;
772 struct gfs2_holder mount_gh
;
777 printk(KERN_WARNING
"GFS2: can't alloc struct gfs2_sbd\n");
781 error
= gfs2_mount_args(sdp
, (char *)data
, 0);
783 printk(KERN_WARNING
"GFS2: can't parse mount arguments\n");
789 error
= init_names(sdp
, silent
);
793 error
= gfs2_sys_fs_add(sdp
);
797 error
= gfs2_lm_mount(sdp
, silent
);
801 error
= init_locking(sdp
, &mount_gh
, DO
);
805 error
= init_sb(sdp
, silent
, DO
);
809 error
= init_inodes(sdp
, DO
);
813 error
= init_per_node(sdp
, DO
);
817 error
= gfs2_statfs_init(sdp
);
819 fs_err(sdp
, "can't initialize statfs subsystem: %d\n", error
);
823 error
= init_threads(sdp
, DO
);
827 if (!(sb
->s_flags
& MS_RDONLY
)) {
828 error
= gfs2_make_fs_rw(sdp
);
830 fs_err(sdp
, "can't make FS RW: %d\n", error
);
835 gfs2_glock_dq_uninit(&mount_gh
);
840 init_threads(sdp
, UNDO
);
843 init_per_node(sdp
, UNDO
);
846 init_inodes(sdp
, UNDO
);
849 init_sb(sdp
, 0, UNDO
);
852 init_locking(sdp
, &mount_gh
, UNDO
);
855 gfs2_gl_hash_clear(sdp
, WAIT
);
856 gfs2_lm_unmount(sdp
);
857 while (invalidate_inodes(sb
))
861 gfs2_sys_fs_del(sdp
);
870 static struct super_block
*gfs2_get_sb(struct file_system_type
*fs_type
,
871 int flags
, const char *dev_name
,
874 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, fill_super
);
877 struct file_system_type gfs2_fs_type
= {
879 .fs_flags
= FS_REQUIRES_DEV
,
880 .get_sb
= gfs2_get_sb
,
881 .kill_sb
= kill_block_super
,
882 .owner
= THIS_MODULE
,