linux-umount-begin-dont-preclude-afs-put-super-from-usefully-calling-afs-shutdown...
[openafs.git] / src / afs / LINUX / osi_vfsops.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * VFS operations for Linux
12  *
13  * super_block operations should return negated errno to Linux.
14  */
15 #include <afsconfig.h>
16 #include "../afs/param.h"
17
18 RCSID("$Header$");
19
20 #include "../afs/sysincludes.h"
21 #include "../afs/afsincludes.h"
22 #include "../afs/afs_stats.h"
23 #include "../h/locks.h"
24 #if defined(AFS_LINUX24_ENV)
25 #include "../h/smp_lock.h"
26 #endif
27
28 #define __NO_VERSION__ /* don't define kernel_verion in module.h */
29 #include <linux/module.h>
30
31
32 struct vcache *afs_globalVp = 0;
33 struct vfs *afs_globalVFS = 0;
34 int afs_was_mounted = 0; /* Used to force reload if mount/unmount/mount */
35
36 extern struct super_operations afs_sops;
37 extern afs_rwlock_t afs_xvcache;
38 extern struct afs_q VLRU;
39
40 extern struct dentry_operations afs_dentry_operations;
41
42 /* Forward declarations */
43 static void iattr2vattr(struct vattr *vattrp, struct iattr *iattrp);
44 static void update_inode_cache(struct inode *ip, struct vattr *vp);
45 static int afs_root(struct super_block *afsp);
46 struct super_block *afs_read_super(struct super_block *sb, void *data,
47                                    int silent);
48 void put_inode_on_dummy_list(struct inode *ip);
49
50 /* afs_file_system
51  * VFS entry for Linux - installed in init_module
52  * Linux mounts file systems by:
53  * 1) register_filesystem(&afs_file_system) - done in init_module
54  * 2) Mount call comes to us via do_mount -> read_super -> afs_read_super.
55  *    We are expected to setup the super_block. See afs_read_super.
56  */
57 #if defined(AFS_LINUX24_ENV)
58 DECLARE_FSTYPE(afs_file_system, "afs", afs_read_super, 0);
59 #else
60 struct file_system_type afs_file_system = {
61     "afs",      /* name - used by mount operation. */
62     0,          /* requires_dev - no for network filesystems. mount() will 
63                  * pass us an "unnamed" device. */
64     afs_read_super, /* wrapper to afs_mount */
65     NULL        /* pointer to next file_system_type once registered. */
66 };
67 #endif
68
69 /* afs_read_super
70  * read the "super block" for AFS - roughly eguivalent to struct vfs.
71  * dev, covered, s_rd_only, s_dirt, and s_type will be set by read_super.
72  */
73 struct super_block *afs_read_super(struct super_block *sb, void *data,
74                                    int silent)
75 {
76     int code = 0;
77
78     AFS_GLOCK();
79     if (afs_was_mounted) {
80         printf("You must reload the AFS kernel extensions before remounting AFS.\n");
81         return NULL;
82     }
83     afs_was_mounted = 1;
84
85     /* Set basics of super_block */
86 #if !defined(AFS_LINUX24_ENV)
87     lock_super(sb);
88 #endif
89     MOD_INC_USE_COUNT;
90
91     afs_globalVFS = sb;
92     sb->s_blocksize = 1024;
93     sb->s_blocksize_bits = 10;
94     sb->s_magic = AFS_VFSMAGIC;
95     sb->s_op = &afs_sops;       /* Super block (vfs) ops */
96 #if defined(MAX_NON_LFS)
97     sb->s_maxbytes = MAX_NON_LFS;
98 #endif
99     code = afs_root(sb);
100     if (code)
101         MOD_DEC_USE_COUNT;
102
103 #if !defined(AFS_LINUX24_ENV)
104     unlock_super(sb);
105 #endif
106
107     AFS_GUNLOCK();
108     return code ? NULL : sb;
109 }
110
111
112 /* afs_root - stat the root of the file system. AFS global held on entry. */
113 static int afs_root(struct super_block *afsp)
114 {
115     register afs_int32 code = 0;
116     struct vrequest treq;
117     register struct vcache *tvp=0;
118
119     AFS_STATCNT(afs_root);
120     if (afs_globalVp && (afs_globalVp->states & CStatd)) {
121         tvp = afs_globalVp;
122     } else {
123         cred_t *credp = crref();
124         afs_globalVp = 0;
125         if (!(code = afs_InitReq(&treq, credp)) &&
126             !(code = afs_CheckInit())) {
127             tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0,
128                                 (struct vcache*)0, WRITE_LOCK);
129             if (tvp) {
130                 extern struct inode_operations afs_dir_iops;
131 #if defined(AFS_LINUX24_ENV)
132                 extern struct file_operations afs_dir_fops;
133 #endif
134                 
135                 /* "/afs" is a directory, reset inode ops accordingly. */
136                 tvp->v.v_op = &afs_dir_iops;
137 #if defined(AFS_LINUX24_ENV)
138                 tvp->v.v_fop = &afs_dir_fops;
139 #endif
140
141                 /* setup super_block and mount point inode. */
142                 afs_globalVp = tvp;
143 #if defined(AFS_LINUX24_ENV)
144                 afsp->s_root = d_alloc_root((struct inode*)&tvp->v);
145 #else
146                 afsp->s_root = d_alloc_root((struct inode*)tvp, NULL);
147 #endif
148                 afsp->s_root->d_op = &afs_dentry_operations;
149             } else
150                 code = ENOENT;
151         }
152         crfree(credp);
153     }
154
155     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, afs_globalVp,
156                ICL_TYPE_INT32, code);
157     return code;
158 }
159
160 /* super_operations */
161
162 /* afs_read_inode
163  * called via iget to read in the inode. The passed in inode has i_ino, i_dev
164  * and i_sb setup on input. Linux file systems use this to get super block
165  * inode information, so we don't really care what happens here.
166  * For Linux 2.2, we'll be called if we participate in the inode pool.
167  */
168 void afs_read_inode(struct inode *ip)
169 {
170     /* I don't think we ever get called with this. So print if we do. */
171     printf("afs_read_inode: Called for inode %d\n", ip->i_ino);
172 }
173
174
175 /* afs_notify_change
176  * Linux version of setattr call. What to change is in the iattr struct.
177  * We need to set bits in both the Linux inode as well as the vcache.
178  */
179 int afs_notify_change(struct dentry *dp, struct iattr* iattrp)
180 {
181     struct vattr vattr;
182     int code;
183     cred_t *credp = crref();
184     struct inode *ip = dp->d_inode;
185
186     AFS_GLOCK();
187     VATTR_NULL(&vattr);
188     iattr2vattr(&vattr, iattrp); /* Convert for AFS vnodeops call. */
189     update_inode_cache(ip, &vattr);
190     code = afs_setattr((struct vcache*)ip, &vattr, credp);
191     afs_CopyOutAttrs((struct vcache*)ip, &vattr);
192     /* Note that the inode may still not have all the correct info. But at
193      * least we've got the newest version of what was supposed to be set.
194      */
195
196     AFS_GUNLOCK();
197     crfree(credp);
198     return -code;
199 }
200
201
202 /* This list is simply used to initialize the i_list member of the
203  * linux inode. This stops linux inode syncing code from choking on our
204  * inodes.
205  */
206 static LIST_HEAD(dummy_inode_list);
207
208
209 /* This is included for documentation only. */
210 /* afs_write_inode
211  * Used to flush in core inode to disk. We don't need to do this. Top level
212  * write_inode() routine will clear i_dirt. If this routine is in the table,
213  * it's expected to do the cleaning and clear i_dirt.
214  * 
215  * 9/24/99: This is what we thought until we discovered msync() does end up calling
216  * this function to sync a single inode to disk. msync() only flushes selective
217  * pages to disk. So it needs an inode syncing function to update metadata when it
218  * has synced some pages of a file to disk.
219  */
220 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
221 void afs_write_inode(struct inode *ip, int unused) 
222 #else
223 void afs_write_inode(struct inode *ip) 
224 #endif
225 {
226     /* and put it back on our dummy list. */
227     list_del(&ip->i_list);
228     list_add(&ip->i_list, &dummy_inode_list);
229
230     /* for now we don't actually update the metadata during msync. This
231      * is just to keep linux happy.  */
232 }
233
234
235 /* afs_put_inode
236  * called from iput when count goes to zero. Linux version of inactive.
237  * For Linux 2.2, this funcionality has moved to the delete inode super op.
238  * If we use the common inode pool, we'll need to set i_nlink to 0 here.
239  * That will trigger the call to delete routine.
240  */
241
242 void afs_delete_inode(struct inode *ip)
243 {
244     struct vcache *vc = (struct vcache*)ip;
245
246     AFS_GLOCK();
247     osi_clear_inode(ip);
248     AFS_GUNLOCK();
249 }
250
251
252 /* afs_put_super
253  * Called from unmount to release super_block. */
254 void afs_put_super(struct super_block *sbp)
255 {
256     extern int afs_afs_cold_shutdown;
257     int code = 0;
258     int fv_slept;
259
260     AFS_GLOCK();
261     AFS_STATCNT(afs_unmount);
262
263     if (!suser()) {
264         AFS_GUNLOCK();
265         return;
266     }
267
268     afs_globalVFS = 0;
269     afs_globalVp = 0;
270     afs_shutdown();
271
272     osi_linux_verify_alloced_memory();
273  done:
274     AFS_GUNLOCK();
275
276     if (!code) {
277         sbp->s_dev = 0;
278         MOD_DEC_USE_COUNT;
279     }
280 }
281
282 #ifdef NOTUSED
283 /* afs_write_super
284  * Not required since we don't write out a super block. */
285 void afs_write_super(struct super_block *sbp)
286 {
287 }
288
289 /* afs_remount_fs
290  * Used to remount filesystems with different flags. Not relevant for AFS.
291  */
292 int afs_remount_fs(struct super_block *sbp, int *, char *)
293 {
294     return -EINVAL;
295 }
296 #endif
297
298 /* afs_statfs
299  * statp is in user space, so we need to cobble together a statfs, then
300  * copy it.
301  */
302 #if defined(AFS_LINUX24_ENV)
303 int afs_statfs(struct super_block *sbp, struct statfs *statp)
304 #else
305 int afs_statfs(struct super_block *sbp, struct statfs *statp, int size)
306 #endif
307 {
308     struct statfs stat;
309
310     AFS_STATCNT(afs_statfs);
311
312 #if !defined(AFS_LINUX24_ENV)
313     if (size < sizeof(struct statfs))
314         return;
315         
316     memset(&stat, 0, size);
317 #endif
318     stat.f_type = 0; /* Can we get a real type sometime? */
319     stat.f_bsize = sbp->s_blocksize;
320     stat.f_blocks =  stat.f_bfree =  stat.f_bavail =  stat.f_files =
321         stat.f_ffree = 9000000;
322     stat.f_fsid.val[0] = AFS_VFSMAGIC;
323     stat.f_fsid.val[1] = AFS_VFSFSID;
324     stat.f_namelen = 256;
325
326 #if defined(AFS_LINUX24_ENV)
327     *statp = stat;
328 #else
329     memcpy_tofs(statp, &stat, size);
330 #endif
331     return 0;
332 }
333
334
335 void 
336 afs_umount_begin(struct super_block *sbp)
337 {
338     afs_put_super(sbp);      
339     afs_shuttingdown=1;
340     afs_was_mounted=0;
341 }
342
343 #if defined(AFS_LINUX24_ENV)
344 struct super_operations afs_sops = {
345     read_inode:        afs_read_inode,
346     write_inode:       afs_write_inode,
347     delete_inode:      afs_delete_inode,
348     put_super:         afs_put_super,
349     statfs:            afs_statfs,
350     umount_begin:      afs_umount_begin,
351 };
352 #else
353 struct super_operations afs_sops = {
354     afs_read_inode,
355     afs_write_inode,            /* afs_write_inode - see doc above. */
356     NULL,               /* afs_put_inode */
357     afs_delete_inode,
358     afs_notify_change,
359     afs_put_super,
360     NULL,               /* afs_write_super - see doc above */
361     afs_statfs,
362     NULL,               /* afs_remount_fs - see doc above */
363     NULL,               /* afs_clear_inode */
364     afs_umount_begin,
365 };
366 #endif
367
368 /************** Support routines ************************/
369
370 /* vattr_setattr
371  * Set iattr data into vattr. Assume vattr cleared before call.
372  */
373 static void iattr2vattr(struct vattr *vattrp, struct iattr *iattrp)
374 {
375     vattrp->va_mask = iattrp->ia_valid;
376     if (iattrp->ia_valid & ATTR_MODE)
377         vattrp->va_mode = iattrp->ia_mode;
378     if (iattrp->ia_valid & ATTR_UID)
379         vattrp->va_uid = iattrp->ia_uid;
380     if (iattrp->ia_valid & ATTR_GID)
381         vattrp->va_gid = iattrp->ia_gid;
382     if (iattrp->ia_valid & ATTR_SIZE)
383         vattrp->va_size = iattrp->ia_size;
384     if (iattrp->ia_valid & ATTR_ATIME) {
385         vattrp->va_atime.tv_sec = iattrp->ia_atime;
386         vattrp->va_atime.tv_usec = 0;
387     }
388     if (iattrp->ia_valid & ATTR_MTIME) {
389         vattrp->va_mtime.tv_sec = iattrp->ia_mtime;
390         vattrp->va_mtime.tv_usec = 0;
391     }
392     if (iattrp->ia_valid & ATTR_CTIME) {
393         vattrp->va_ctime.tv_sec = iattrp->ia_ctime;
394         vattrp->va_ctime.tv_usec = 0;
395     }
396 }
397
398 /* update_inode_cache
399  * Update inode with info from vattr struct. Use va_mask to determine what
400  * to update.
401  */
402 static void update_inode_cache(struct inode *ip, struct vattr *vp)
403 {
404     if (vp->va_mask & ATTR_MODE)
405         ip->i_mode = vp->va_mode;
406     if (vp->va_mask & ATTR_UID)
407         ip->i_uid = vp->va_uid;
408     if (vp->va_mask & ATTR_GID)
409         ip->i_gid = vp->va_gid;
410     if (vp->va_mask & ATTR_SIZE)
411         ip->i_size = vp->va_size;
412     if (vp->va_mask & ATTR_ATIME)
413         ip->i_atime = vp->va_atime.tv_sec;
414     if (vp->va_mask & ATTR_MTIME)
415         ip->i_mtime = vp->va_mtime.tv_sec;
416     if (vp->va_mask & ATTR_CTIME)
417         ip->i_ctime = vp->va_ctime.tv_sec;
418 }
419
420 /* vattr2inode
421  * Rewrite the inode cache from the attr. Assumes all vattr fields are valid.
422  */
423 void vattr2inode(struct inode *ip, struct vattr *vp)
424 {
425     ip->i_ino = vp->va_nodeid;
426     ip->i_nlink = vp->va_nlink;
427     ip->i_blocks = vp->va_blocks;
428     ip->i_blksize = vp->va_blocksize;
429     ip->i_rdev = vp->va_rdev;
430     ip->i_mode = vp->va_mode;
431     ip->i_uid = vp->va_uid;
432     ip->i_gid = vp->va_gid;
433     ip->i_size = vp->va_size;
434     ip->i_atime = vp->va_atime.tv_sec;
435     ip->i_mtime = vp->va_mtime.tv_sec;
436     ip->i_ctime = vp->va_ctime.tv_sec;
437
438     /* we should put our inodes on a dummy inode list to keep linux happy.*/
439     if (!ip->i_list.prev && !ip->i_list.next) { 
440         /* this might be bad as we are reaching under the covers of the 
441          * list structure but we want to avoid putting the inode 
442          * on the list more than once.   */
443         put_inode_on_dummy_list(ip);
444     }
445 }
446
447 /* Put this afs inode on our own dummy list. Linux expects to see inodes
448  * nicely strung up in lists. Linux inode syncing code chokes on our inodes if
449  * they're not on any lists.
450  */
451 void put_inode_on_dummy_list(struct inode *ip)
452 {
453     /* Initialize list. See explanation above. */
454     list_add(&ip->i_list, &dummy_inode_list);
455 }
456
457 /* And yet another routine to update the inode cache - called from ProcessFS */
458 void vcache2inode(struct vcache *avc)
459 {
460     struct vattr vattr;
461
462     VATTR_NULL(&vattr);
463     afs_CopyOutAttrs(avc, &vattr); /* calls vattr2inode */
464 }