6 #define DEBUG_SUBSYSTEM S_SM
8 #include <linux/kmod.h>
9 #include <linux/init.h>
11 #include <linux/slab.h>
12 #include <linux/string.h>
13 #include "smfs_internal.h"
15 void duplicate_inode(struct inode *cache_inode, struct inode *inode)
18 inode->i_mode = cache_inode->i_mode;
19 inode->i_uid = cache_inode->i_uid;
20 inode->i_gid = cache_inode->i_gid;
22 inode->i_nlink = cache_inode->i_nlink;
23 inode->i_size = cache_inode->i_size;
24 inode->i_atime = cache_inode->i_atime;
25 inode->i_ctime = cache_inode->i_ctime;
26 inode->i_mtime = cache_inode->i_mtime;
27 inode->i_blksize = cache_inode->i_blksize; /* This is the optimal IO size
28 * (for stat), not the fs block
30 inode->i_blocks = cache_inode->i_blocks;
31 inode->i_version = cache_inode->i_version;
32 inode->i_state = cache_inode->i_state;
34 static void smfs_read_inode(struct inode *inode)
36 struct super_block *cache_sb;
37 struct inode *cache_inode;
43 CDEBUG(D_INODE, "read_inode ino %lu\n", inode->i_ino);
44 cache_sb = S2CSB(inode->i_sb);
46 cache_inode = iget(cache_sb, inode->i_ino);
47 I2CI(inode) = cache_inode;
49 if(cache_sb && cache_sb->s_op->read_inode)
50 cache_sb->s_op->read_inode(cache_inode);
52 duplicate_inode(cache_inode, inode);
53 sm_set_inode_ops(cache_inode, inode);
55 CDEBUG(D_INODE, "read_inode ino %lu icount %d \n",
56 inode->i_ino, atomic_read(&inode->i_count));
61 /* Although some filesystem(such as ext3) do not have
62 * clear_inode method, but we need it to free the
65 static void smfs_clear_inode(struct inode *inode)
67 struct super_block *cache_sb;
68 struct inode *cache_inode;
74 cache_sb = S2CSB(inode->i_sb);
75 cache_inode = I2CI(inode);
77 /*FIXME: because i_count of cache_inode may not
78 * be 0 or 1 in before smfs_delete inode, So we
79 * need to dec it to 1 before we call delete_inode
80 * of the bellow cache filesystem Check again latter*/
82 if (atomic_read(&cache_inode->i_count) < 1)
85 while (atomic_read(&cache_inode->i_count) != 1) {
86 atomic_dec(&cache_inode->i_count);
93 static void smfs_delete_inode(struct inode *inode)
95 struct inode *cache_inode;
96 struct super_block *cache_sb;
99 cache_inode = I2CI(inode);
100 cache_sb = S2CSB(inode->i_sb);
102 if (!cache_inode || !cache_sb)
105 /*FIXME: because i_count of cache_inode may not
106 * be 0 or 1 in before smfs_delete inode, So we
107 * need to dec it to 1 before we call delete_inode
108 * of the bellow cache filesystem Check again latter*/
110 if (atomic_read(&cache_inode->i_count) < 1)
113 while (atomic_read(&cache_inode->i_count) != 1) {
114 atomic_dec(&cache_inode->i_count);
117 duplicate_inode(inode, cache_inode);
119 list_del(&cache_inode->i_hash);
120 INIT_LIST_HEAD(&cache_inode->i_hash);
121 list_del(&cache_inode->i_list);
122 INIT_LIST_HEAD(&cache_inode->i_list);
124 if (cache_inode->i_data.nrpages)
125 truncate_inode_pages(&cache_inode->i_data, 0);
127 if (cache_sb->s_op->delete_inode)
128 cache_sb->s_op->delete_inode(cache_inode);
130 duplicate_inode(cache_inode, inode);
135 static void smfs_write_inode(struct inode *inode, int wait)
137 struct inode *cache_inode;
138 struct super_block *cache_sb;
141 cache_inode = I2CI(inode);
142 cache_sb = S2CSB(inode->i_sb);
144 if (!cache_inode || !cache_sb)
147 if (cache_sb->s_op->write_inode)
148 cache_sb->s_op->write_inode(cache_inode, wait);
150 duplicate_inode(cache_inode, inode);
154 static void smfs_dirty_inode(struct inode *inode)
156 struct inode *cache_inode;
157 struct super_block *cache_sb;
160 cache_inode = I2CI(inode);
161 cache_sb = S2CSB(inode->i_sb);
163 if (!cache_inode || !cache_sb)
166 duplicate_inode(inode, cache_inode);
167 if (cache_sb->s_op->dirty_inode)
168 cache_sb->s_op->dirty_inode(cache_inode);
170 duplicate_inode(cache_inode, inode);
174 static void smfs_put_inode(struct inode *inode)
176 struct inode *cache_inode;
177 struct super_block *cache_sb;
180 cache_inode = I2CI(inode);
181 cache_sb = S2CSB(inode->i_sb);
183 if (!cache_inode || !cache_sb)
185 if (cache_sb->s_op->put_inode)
186 cache_sb->s_op->put_inode(cache_inode);
191 static void smfs_write_super(struct super_block *sb)
193 struct super_block *cache_sb;
196 cache_sb = S2CSB(sb);
201 if (cache_sb->s_op->write_super)
202 cache_sb->s_op->write_super(cache_sb);
204 duplicate_sb(cache_sb, sb);
208 static void smfs_write_super_lockfs(struct super_block *sb)
210 struct super_block *cache_sb;
213 cache_sb = S2CSB(sb);
218 if (cache_sb->s_op->write_super_lockfs)
219 cache_sb->s_op->write_super_lockfs(cache_sb);
221 duplicate_sb(cache_sb, sb);
225 static void smfs_unlockfs(struct super_block *sb)
227 struct super_block *cache_sb;
230 cache_sb = S2CSB(sb);
235 if (cache_sb->s_op->unlockfs)
236 cache_sb->s_op->unlockfs(cache_sb);
238 duplicate_sb(cache_sb, sb);
241 static int smfs_statfs(struct super_block * sb, struct statfs * buf)
243 struct super_block *cache_sb;
247 cache_sb = S2CSB(sb);
252 if (cache_sb->s_op->statfs)
253 rc = cache_sb->s_op->statfs(cache_sb, buf);
255 duplicate_sb(cache_sb, sb);
259 static int smfs_remount(struct super_block * sb, int * flags, char * data)
261 struct super_block *cache_sb;
265 cache_sb = S2CSB(sb);
270 if (cache_sb->s_op->remount_fs)
271 rc = cache_sb->s_op->remount_fs(cache_sb, flags, data);
273 duplicate_sb(cache_sb, sb);
276 struct super_operations smfs_super_ops = {
277 read_inode: smfs_read_inode,
278 clear_inode: smfs_clear_inode,
279 put_super: smfs_put_super,
280 delete_inode: smfs_delete_inode,
281 write_inode: smfs_write_inode,
282 dirty_inode: smfs_dirty_inode, /* BKL not held. We take it */
283 put_inode: smfs_put_inode, /* BKL not held. Don't need */
285 write_super: smfs_write_super, /* BKL held */
286 write_super_lockfs: smfs_write_super_lockfs, /* BKL not held. Take it */
287 unlockfs: smfs_unlockfs, /* BKL not held. We take it */
288 statfs: smfs_statfs, /* BKL held */
289 remount_fs: smfs_remount, /* BKL held */