linux-cleanup-after-check-bad-parent-20010416
[openafs.git] / src / afs / LINUX / osi_misc.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  * Linux support routines.
12  *
13  */
14 #include "../afs/param.h"
15 #include "../afs/sysincludes.h"
16 #include "../afs/afsincludes.h"
17 #include "../afs/afs_stats.h"
18 #if defined(AFS_LINUX24_ENV)
19 #include "../h/smp_lock.h"
20 #endif
21
22 char *crash_addr = 0; /* Induce an oops by writing here. */
23
24 /* Lookup name and return vnode for same. */
25 int osi_lookupname(char *aname, uio_seg_t seg, int followlink,
26                vnode_t **dirvpp, struct dentry **dpp)
27 {
28 #if defined(AFS_LINUX24_ENV)
29     struct nameidata nd;
30 #else
31     struct dentry *dp = NULL;
32 #endif
33     int code;
34
35     code = ENOENT;
36 #if defined(AFS_LINUX24_ENV)
37     if (seg == AFS_UIOUSER) {
38         code = followlink ?
39             user_path_walk(aname, &nd) : user_path_walk_link(aname, &nd);
40     }
41     else {
42         if (path_init(aname, followlink ? LOOKUP_FOLLOW : 0, &nd))
43             code = path_walk(aname, &nd);
44     }
45
46     if (!code) {
47         if (nd.dentry->d_inode) {
48             *dpp = nd.dentry;
49             code = 0;
50         }
51         else
52             path_release(&nd);
53     }
54 #else
55     if (seg == AFS_UIOUSER) {
56         dp = followlink ? namei(aname) : lnamei(aname);
57     }
58     else {
59         dp = lookup_dentry(aname, NULL, followlink ? 1 : 0);
60     }
61
62     if (dp && !IS_ERR(dp)) {
63         if (dp->d_inode) {
64             *dpp = dp;
65             code = 0;
66         }
67         else
68             dput(dp);
69     }
70 #endif
71             
72     return code;
73 }
74
75 /* Intialize cache device info and fragment size for disk cache partition. */
76 int osi_InitCacheInfo(char *aname)
77 {
78     int code;
79     struct dentry *dp;
80     extern ino_t cacheInode;
81     extern struct osi_dev cacheDev;
82     extern afs_int32 afs_fsfragsize;
83     extern struct super_block *afs_cacheSBp;
84
85     code = osi_lookupname(aname, AFS_UIOSYS, 1, NULL, &dp);
86     if (code) return ENOENT;
87
88     cacheInode = dp->d_inode->i_ino;
89     cacheDev.dev = dp->d_inode->i_dev;
90     afs_fsfragsize = dp->d_inode->i_sb->s_blocksize;
91     afs_cacheSBp = dp->d_inode->i_sb;
92
93     dput(dp);
94
95     return 0;
96 }
97
98
99 #define FOP_READ(F, B, C) (F)->f_op->read(F, B, (size_t)(C), &(F)->f_pos)
100 #define FOP_WRITE(F, B, C) (F)->f_op->write(F, B, (size_t)(C), &(F)->f_pos)
101
102 /* osi_rdwr
103  * Seek, then read or write to an open inode. addrp points to data in
104  * kernel space.
105  */
106 int osi_rdwr(int rw, struct osi_file *file, caddr_t addrp, size_t asize,
107              size_t *resid)
108 {
109     int code = 0;
110     KERNEL_SPACE_DECL;
111     struct file *filp = &file->file;
112     off_t offset = file->offset;
113
114     /* Seek to the desired position. Return -1 on error. */
115     if (filp->f_op->llseek) {
116         if (filp->f_op->llseek(filp, (loff_t)offset, 0) != offset)
117             return -1;
118     }
119     else
120         filp->f_pos = offset;
121
122     /* Read/Write the data. */
123     TO_USER_SPACE();
124     if (rw == UIO_READ)
125         code = FOP_READ(filp, addrp, asize);
126     else if (rw == UIO_WRITE)
127         code = FOP_WRITE(filp, addrp, asize);
128     else /* all is well? */
129         code = asize;
130     TO_KERNEL_SPACE();
131
132     if (code >=0) {
133         *resid = asize - code;
134         return 0;
135     }
136     else
137         return -1;
138 }
139
140 /* This variant is called from AFS read/write routines and takes a uio
141  * struct and, if successful, returns 0.
142  */
143 int osi_file_uio_rdwr(struct osi_file *osifile, uio_t *uiop, int rw)
144 {
145     struct file *filp = &osifile->file;
146     struct inode *ip = FILE_INODE(&osifile->file);
147     KERNEL_SPACE_DECL;
148     int code = 0;
149     struct iovec *iov;
150     int count;
151
152     if (uiop->uio_seg == AFS_UIOSYS)
153         TO_USER_SPACE();
154
155     filp->f_pos = uiop->uio_offset;
156     while (code == 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
157         iov = uiop->uio_iov;
158         count = iov->iov_len;
159         if (count == 0) {
160             uiop->uio_iov++;
161             uiop->uio_iovcnt--;
162             continue;
163         }
164         
165         if (rw == UIO_READ)
166             code = FOP_READ(filp, iov->iov_base, count);
167         else
168             code = FOP_WRITE(filp, iov->iov_base, count);
169
170         if (code < 0) {
171             code = -code;
172             break;
173         }
174         
175         iov->iov_base += code;
176         iov->iov_len -= code;
177         uiop->uio_resid -= code;
178         uiop->uio_offset += code;
179         code = 0;
180     }
181
182     if (uiop->uio_seg == AFS_UIOSYS)
183         TO_KERNEL_SPACE();
184
185     return code;
186 }
187
188 /* setup_uio 
189  * Setup a uio struct.
190  */
191 void setup_uio(uio_t *uiop, struct iovec *iovecp, char *buf,
192                              int pos, int count, uio_flag_t flag,
193                              uio_seg_t seg)
194 {
195     iovecp->iov_base = buf;
196     iovecp->iov_len = count;
197     uiop->uio_iov = iovecp;
198     uiop->uio_iovcnt = 1;
199     uiop->uio_offset = pos;
200     uiop->uio_seg = seg;
201     uiop->uio_resid = count;
202     uiop->uio_flag = flag;
203 }
204
205
206 /* uiomove
207  * UIO_READ : dp -> uio
208  * UIO_WRITE : uio -> dp
209  */
210 int uiomove(char *dp, int length, uio_flag_t rw, uio_t *uiop)
211 {
212     int count, n;
213     struct iovec *iov;
214     int code;
215
216     while (length > 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
217         iov = uiop->uio_iov;
218         count = iov->iov_len;
219
220         if (!count) {
221             uiop->uio_iov++;
222             uiop->uio_iovcnt--;
223             continue;
224         }
225
226         if (count > length)
227             count = length;
228         
229         switch(uiop->uio_seg) {
230         case AFS_UIOSYS:
231             switch(rw) {
232             case UIO_READ:
233                 memcpy(iov->iov_base, dp, count); break;
234             case UIO_WRITE:
235                 memcpy(dp, iov->iov_base, count); break;
236             default:
237                 printf("uiomove: Bad rw = %d\n", rw);
238                 return -EINVAL;
239             }
240             break;
241         case AFS_UIOUSER:
242             switch(rw) {
243             case UIO_READ:
244                 AFS_COPYOUT(dp, iov->iov_base, count, code); break;
245             case UIO_WRITE:
246                 AFS_COPYIN(iov->iov_base, dp, count, code); break;
247             default:
248                 printf("uiomove: Bad rw = %d\n", rw);
249                 return -EINVAL;
250             }
251             break;
252         default:
253             printf("uiomove: Bad seg = %d\n", uiop->uio_seg);
254             return -EINVAL;
255         }
256
257         dp += count;
258         length -= count;
259         iov->iov_base += count;
260         iov->iov_len -= count;
261         uiop->uio_offset += count;
262         uiop->uio_resid -= count;
263     }
264     return 0;
265 }
266
267 void afs_osi_SetTime(osi_timeval_t *tvp)
268 {
269     extern int (*sys_settimeofdayp)(struct timeval *tv, struct timezone *tz);
270 #ifdef AFS_LINUX_64BIT_KERNEL
271     struct timeval tv;
272     AFS_STATCNT(osi_SetTime);
273     tv.tv_sec = tvp->tv_sec;
274     tv.tv_usec = tvp->tv_usec;
275     (void) (*sys_settimeofdayp)(&tv, NULL);
276 #else
277     KERNEL_SPACE_DECL;
278
279     AFS_STATCNT(osi_SetTime);
280
281     TO_USER_SPACE();
282     (void) (*sys_settimeofdayp)(tvp, NULL);
283     TO_KERNEL_SPACE();
284 #endif
285 }
286
287 /* Free all the pages on any of the vnodes in the vlru. Must be done before
288  * freeing all memory.
289  */
290 void osi_linux_free_inode_pages(void)
291 {
292     int i;
293     struct vcache *tvc;
294     struct inode *ip;
295     extern struct vcache *afs_vhashT[VCSIZE];
296
297     for (i=0; i<VCSIZE; i++) {
298         for(tvc = afs_vhashT[i]; tvc; tvc=tvc->hnext) {
299             ip = (struct inode*)tvc;
300 #if defined(AFS_LINUX24_ENV)
301             if (ip->i_data.nrpages) {
302 #else
303             if (ip->i_nrpages) {
304 #endif
305                 invalidate_inode_pages(ip);
306 #if defined(AFS_LINUX24_ENV)
307                 if (ip->i_data.nrpages) {
308 #else
309                 if (ip->i_nrpages) {
310 #endif
311                     printf("Failed to invalidate all pages on inode 0x%x\n",
312                            ip);
313                 }
314             }
315         }
316     }
317 }
318
319 void osi_clear_inode(struct inode *ip)
320 {
321     cred_t *credp = crref();
322     struct vcache *vc = (struct vcache*)ip;
323
324 #if defined(AFS_LINUX24_ENV)
325     if (atomic_read(&ip->i_count) > 1)
326 #else
327     if (ip->i_count > 1)
328 #endif
329         printf("afs_put_inode: ino %d (0x%x) has count %d\n", ip->i_ino, ip);
330
331     afs_InactiveVCache(vc, credp);
332 #if defined(AFS_LINUX24_ENV)
333     atomic_set(&ip->i_count, 0);
334 #else
335     ip->i_count = 0;
336 #endif
337     ip->i_nlink = 0; /* iput checks this after calling this routine. */
338     crfree(credp);
339 }
340
341 /* iput an inode. Since we still have a separate inode pool, we don't want
342  * to call iput on AFS inodes, since they would then end up on Linux's
343  * inode_unsed list.
344  */
345 void osi_iput(struct inode *ip)
346 {
347     extern struct vfs *afs_globalVFS;
348
349     AFS_GLOCK();
350 #if defined(AFS_LINUX24_ENV)
351     if (atomic_read(&ip->i_count) == 0 || atomic_read(&ip->i_count) & 0xffff0000) {
352 #else
353     if (ip->i_count == 0 || ip->i_count & 0xffff0000) {
354 #endif
355         osi_Panic("IPUT Bad refCount %d on inode 0x%x\n",
356 #if defined(AFS_LINUX24_ENV)
357                   atomic_read(&ip->i_count), ip);
358 #else
359                   ip->i_count, ip);
360 #endif
361     }
362     if (afs_globalVFS && afs_globalVFS == ip->i_sb ) {
363 #if defined(AFS_LINUX24_ENV)
364         atomic_dec(&ip->i_count);
365         if (!atomic_read(&ip->i_count))
366 #else
367         ip->i_count --;
368         if (!ip->i_count)
369 #endif
370             osi_clear_inode(ip);
371         AFS_GUNLOCK();
372     }
373     else { 
374         AFS_GUNLOCK();
375         iput(ip);
376     }
377 }
378
379 /* check_bad_parent() : Checks if this dentry's vcache is a root vcache
380  * that has its mvid (parent dir's fid) pointer set to the wrong directory
381  * due to being mounted in multiple points at once. If so, check_bad_parent()
382  * calls afs_lookup() to correct the vcache's mvid, as well as the volume's
383  * dotdotfid and mtpoint fid members.
384  * Parameters:
385  *  dp - dentry to be checked.
386  * Return Values:
387  *  None.
388  * Sideeffects:
389  *   This dentry's vcache's mvid will be set to the correct parent directory's
390  *   fid.
391  *   This root vnode's volume will have its dotdotfid and mtpoint fids set
392  *    to the correct parent and mountpoint fids.
393  */
394
395 void check_bad_parent(struct dentry *dp)
396 {
397   cred_t *credp;
398   struct vcache *vcp = (struct vcache*)dp->d_inode, *avc = NULL;
399   struct vcache *pvc = (struct vcache *)dp->d_parent->d_inode;
400
401   if (vcp->mvid->Fid.Volume != pvc->fid.Fid.Volume) { /* bad parent */
402     credp = crref();
403
404
405     /* force a lookup, so vcp->mvid is fixed up */
406     afs_lookup(pvc, dp->d_name.name, &avc, credp);
407     if (!avc || vcp != avc) {    /* bad, very bad.. */
408       afs_Trace4(afs_iclSetp, CM_TRACE_TMP_1S3L, ICL_TYPE_STRING,
409                  "afs_linux_revalidate : bad pointer returned from afs_lookup origvc newvc dentry",
410                  ICL_TYPE_POINTER, vcp,
411                  ICL_TYPE_POINTER, avc,
412                  ICL_TYPE_POINTER, dp);
413     }
414     if (avc)
415         AFS_RELE(avc);
416     crfree(credp);
417   } /* if bad parent */
418  
419   return;
420 }