fix-linux22-20050310
[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 <afsconfig.h>
15 #include "afs/param.h"
16
17 RCSID
18     ("$Header$");
19
20 #include "afs/sysincludes.h"
21 #include "afsincludes.h"
22 #include "afs/afs_stats.h"
23 #if defined(AFS_LINUX24_ENV)
24 #include "h/smp_lock.h"
25 #endif
26 #if defined(AFS_LINUX26_ENV)
27 #include "h/namei.h"
28 #endif
29
30 #if defined(AFS_LINUX24_ENV)
31 /* LOOKUP_POSITIVE is becoming the default */
32 #ifndef LOOKUP_POSITIVE
33 #define LOOKUP_POSITIVE 0
34 #endif
35 /* Lookup name and return vnode for same. */
36 int
37 osi_lookupname_internal(char *aname, int followlink, struct vfsmount **mnt,
38                         struct dentry **dpp)
39 {
40     int code;
41     struct nameidata nd;
42     int flags = LOOKUP_POSITIVE;
43     code = ENOENT;
44
45     if (followlink)
46        flags |= LOOKUP_FOLLOW;
47 #if defined(AFS_LINUX26_ENV)
48     code = path_lookup(aname, flags, &nd);
49 #else
50     if (path_init(aname, flags, &nd))
51         code = path_walk(aname, &nd);
52 #endif
53
54     if (!code) {
55         *dpp = dget(nd.dentry);
56         if (mnt)
57            *mnt = mntget(nd.mnt);
58         path_release(&nd);
59     }
60     return code;
61 }
62 int
63 osi_lookupname(char *aname, uio_seg_t seg, int followlink, 
64                         struct dentry **dpp)
65 {
66     int code;
67     char *tname;
68     code = ENOENT;
69     if (seg == AFS_UIOUSER) {
70         tname = getname(aname);
71         if (IS_ERR(tname)) 
72             return PTR_ERR(tname);
73     } else {
74         tname = aname;
75     }
76     code = osi_lookupname_internal(tname, followlink, NULL, dpp);   
77     if (seg == AFS_UIOUSER) {
78         putname(tname);
79     }
80     return code;
81 }
82 #else
83 int
84 osi_lookupname(char *aname, uio_seg_t seg, int followlink, struct dentry **dpp)
85 {
86     struct dentry *dp = NULL;
87     int code;
88
89     code = ENOENT;
90     if (seg == AFS_UIOUSER) {
91         dp = followlink ? namei(aname) : lnamei(aname);
92     } else {
93         dp = lookup_dentry(aname, NULL, followlink ? 1 : 0);
94     }
95
96     if (dp && !IS_ERR(dp)) {
97         if (dp->d_inode) {
98             *dpp = dp;
99             code = 0;
100         } else
101             dput(dp);
102     }
103
104     return code;
105 }
106 #endif
107
108 /* Intialize cache device info and fragment size for disk cache partition. */
109 int
110 osi_InitCacheInfo(char *aname)
111 {
112     int code;
113     struct dentry *dp,*dpp;
114     extern ino_t cacheInode;
115     extern struct osi_dev cacheDev;
116     extern afs_int32 afs_fsfragsize;
117     extern struct super_block *afs_cacheSBp;
118     extern struct vfsmnt *afs_cacheMnt;
119     code = osi_lookupname_internal(aname, 1, &afs_cacheMnt, &dp);
120     if (code)
121         return ENOENT;
122
123     cacheInode = dp->d_inode->i_ino;
124     cacheDev.dev = dp->d_inode->i_sb->s_dev;
125     afs_fsfragsize = dp->d_inode->i_sb->s_blocksize - 1;
126     afs_cacheSBp = dp->d_inode->i_sb;
127
128     dput(dp);
129
130     return 0;
131 }
132
133
134 #define FOP_READ(F, B, C) (F)->f_op->read(F, B, (size_t)(C), &(F)->f_pos)
135 #define FOP_WRITE(F, B, C) (F)->f_op->write(F, B, (size_t)(C), &(F)->f_pos)
136
137 /* osi_rdwr
138  * Seek, then read or write to an open inode. addrp points to data in
139  * kernel space.
140  */
141 int
142 osi_rdwr(int rw, struct osi_file *file, caddr_t addrp, size_t asize,
143          size_t * resid)
144 {
145     int code = 0;
146     KERNEL_SPACE_DECL;
147     struct file *filp = &file->file;
148     off_t offset = file->offset;
149     unsigned long savelim;
150
151     /* Seek to the desired position. Return -1 on error. */
152     if (filp->f_op->llseek) {
153         if (filp->f_op->llseek(filp, (loff_t) offset, 0) != offset)
154             return -1;
155     } else
156         filp->f_pos = offset;
157
158     savelim = current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur;
159     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
160
161     /* Read/Write the data. */
162     TO_USER_SPACE();
163     if (rw == UIO_READ)
164         code = FOP_READ(filp, addrp, asize);
165     else if (rw == UIO_WRITE)
166         code = FOP_WRITE(filp, addrp, asize);
167     else                        /* all is well? */
168         code = asize;
169     TO_KERNEL_SPACE();
170
171     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = savelim;
172
173     if (code >= 0) {
174         *resid = asize - code;
175         return 0;
176     } else
177         return -1;
178 }
179
180 /* This variant is called from AFS read/write routines and takes a uio
181  * struct and, if successful, returns 0.
182  */
183 int
184 osi_file_uio_rdwr(struct osi_file *osifile, uio_t * uiop, int rw)
185 {
186     struct file *filp = &osifile->file;
187     KERNEL_SPACE_DECL;
188     int code = 0;
189     struct iovec *iov;
190     int count;
191     unsigned long savelim;
192
193     savelim = current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur;
194     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
195
196     if (uiop->uio_seg == AFS_UIOSYS)
197         TO_USER_SPACE();
198
199     filp->f_pos = uiop->uio_offset;
200     while (code == 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
201         iov = uiop->uio_iov;
202         count = iov->iov_len;
203         if (count == 0) {
204             uiop->uio_iov++;
205             uiop->uio_iovcnt--;
206             continue;
207         }
208
209         if (rw == UIO_READ)
210             code = FOP_READ(filp, iov->iov_base, count);
211         else
212             code = FOP_WRITE(filp, iov->iov_base, count);
213
214         if (code < 0) {
215             code = -code;
216             break;
217         } else if (code == 0) {
218             /*
219              * This is bad -- we can't read any more data from the
220              * file, but we have no good way of signaling a partial
221              * read either.
222              */
223             code = EIO;
224             break;
225         }
226
227         iov->iov_base += code;
228         iov->iov_len -= code;
229         uiop->uio_resid -= code;
230         uiop->uio_offset += code;
231         code = 0;
232     }
233
234     if (uiop->uio_seg == AFS_UIOSYS)
235         TO_KERNEL_SPACE();
236
237     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = savelim;
238
239     return code;
240 }
241
242 /* setup_uio 
243  * Setup a uio struct.
244  */
245 void
246 setup_uio(uio_t * uiop, struct iovec *iovecp, const char *buf, afs_offs_t pos,
247           int count, uio_flag_t flag, uio_seg_t seg)
248 {
249     iovecp->iov_base = (char *)buf;
250     iovecp->iov_len = count;
251     uiop->uio_iov = iovecp;
252     uiop->uio_iovcnt = 1;
253     uiop->uio_offset = pos;
254     uiop->uio_seg = seg;
255     uiop->uio_resid = count;
256     uiop->uio_flag = flag;
257 }
258
259
260 /* uiomove
261  * UIO_READ : dp -> uio
262  * UIO_WRITE : uio -> dp
263  */
264 int
265 uiomove(char *dp, int length, uio_flag_t rw, uio_t * uiop)
266 {
267     int count;
268     struct iovec *iov;
269     int code;
270
271     while (length > 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
272         iov = uiop->uio_iov;
273         count = iov->iov_len;
274
275         if (!count) {
276             uiop->uio_iov++;
277             uiop->uio_iovcnt--;
278             continue;
279         }
280
281         if (count > length)
282             count = length;
283
284         switch (uiop->uio_seg) {
285         case AFS_UIOSYS:
286             switch (rw) {
287             case UIO_READ:
288                 memcpy(iov->iov_base, dp, count);
289                 break;
290             case UIO_WRITE:
291                 memcpy(dp, iov->iov_base, count);
292                 break;
293             default:
294                 printf("uiomove: Bad rw = %d\n", rw);
295                 return -EINVAL;
296             }
297             break;
298         case AFS_UIOUSER:
299             switch (rw) {
300             case UIO_READ:
301                 AFS_COPYOUT(dp, iov->iov_base, count, code);
302                 break;
303             case UIO_WRITE:
304                 AFS_COPYIN(iov->iov_base, dp, count, code);
305                 break;
306             default:
307                 printf("uiomove: Bad rw = %d\n", rw);
308                 return -EINVAL;
309             }
310             break;
311         default:
312             printf("uiomove: Bad seg = %d\n", uiop->uio_seg);
313             return -EINVAL;
314         }
315
316         dp += count;
317         length -= count;
318         iov->iov_base += count;
319         iov->iov_len -= count;
320         uiop->uio_offset += count;
321         uiop->uio_resid -= count;
322     }
323     return 0;
324 }
325
326 void
327 afs_osi_SetTime(osi_timeval_t * tvp)
328 {
329 #if defined(AFS_LINUX24_ENV)
330
331 #if defined(AFS_LINUX26_ENV)
332     struct timespec tv;
333     tv.tv_sec = tvp->tv_sec;
334     tv.tv_nsec = tvp->tv_usec * NSEC_PER_USEC;
335 #else
336     struct timeval tv;
337     tv.tv_sec = tvp->tv_sec;
338     tv.tv_usec = tvp->tv_usec;
339 #endif
340
341     AFS_STATCNT(osi_SetTime);
342
343     do_settimeofday(&tv);
344 #else
345     extern int (*sys_settimeofdayp) (struct timeval * tv,
346                                      struct timezone * tz);
347
348     KERNEL_SPACE_DECL;
349
350     AFS_STATCNT(osi_SetTime);
351
352     TO_USER_SPACE();
353     if (sys_settimeofdayp)
354         (void)(*sys_settimeofdayp) (tvp, NULL);
355     TO_KERNEL_SPACE();
356 #endif
357 }
358
359 /* Free all the pages on any of the vnodes in the vlru. Must be done before
360  * freeing all memory.
361  */
362 void
363 osi_linux_free_inode_pages(void)
364 {
365     int i;
366     struct vcache *tvc;
367     struct inode *ip;
368     extern struct vcache *afs_vhashT[VCSIZE];
369
370     for (i = 0; i < VCSIZE; i++) {
371         for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
372             ip = AFSTOI(tvc);
373 #if defined(AFS_LINUX24_ENV)
374             if (ip->i_data.nrpages) {
375 #else
376             if (ip->i_nrpages) {
377 #endif
378 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
379                 truncate_inode_pages(&ip->i_data, 0);
380 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,15)
381                 truncate_inode_pages(ip, 0);
382 #else
383                 invalidate_inode_pages(ip);
384 #endif
385 #if defined(AFS_LINUX24_ENV)
386                 if (ip->i_data.nrpages) {
387 #else
388                 if (ip->i_nrpages) {
389 #endif
390                     printf("Failed to invalidate all pages on inode 0x%lx\n",
391                            (unsigned long)ip);
392                 }
393             }
394         }
395     }
396 }
397
398 void
399 osi_clear_inode(struct inode *ip)
400 {
401     cred_t *credp = crref();
402     struct vcache *vcp = ITOAFS(ip);
403
404 #if defined(AFS_LINUX24_ENV)
405     if (atomic_read(&ip->i_count) > 1)
406         printf("afs_put_inode: ino %ld (0x%lx) has count %ld\n",
407                (long)ip->i_ino, (unsigned long)ip,
408                (long)atomic_read(&ip->i_count));
409 #else
410     if (ip->i_count > 1)
411         printf("afs_put_inode: ino %ld (0x%lx) has count %ld\n",
412                (long)ip->i_ino, (unsigned long)ip, (long)ip->i_count);
413 #endif
414
415     afs_InactiveVCache(vcp, credp);
416     ObtainWriteLock(&vcp->lock, 504);
417     ip->i_nlink = 0;            /* iput checks this after calling this routine. */
418 #ifdef I_CLEAR
419     ip->i_state = I_CLEAR;
420 #endif
421     ReleaseWriteLock(&vcp->lock);
422     crfree(credp);
423 }
424
425 #if !defined(AFS_LINUX26_ENV)
426 /* iput an inode. Since we still have a separate inode pool, we don't want
427  * to call iput on AFS inodes, since they would then end up on Linux's
428  * inode_unsed list.
429  */
430 void
431 osi_iput(struct inode *ip)
432 {
433     extern struct vfs *afs_globalVFS;
434
435     AFS_GLOCK();
436
437     if (afs_globalVFS && ip->i_sb != afs_globalVFS)
438         osi_Panic("IPUT Not an afs inode\n");
439
440 #if defined(AFS_LINUX24_ENV)
441     if (atomic_read(&ip->i_count) == 0)
442 #else
443     if (ip->i_count == 0)
444 #endif
445         osi_Panic("IPUT Bad refCount %d on inode 0x%x\n",
446 #if defined(AFS_LINUX24_ENV)
447                   atomic_read(&ip->i_count),
448 #else
449                   ip->i_count,
450 #endif
451                                 ip);
452
453 #if defined(AFS_LINUX24_ENV)
454     if (atomic_dec_and_test(&ip->i_count))
455 #else
456     if (!--ip->i_count)
457 #endif
458                                            {
459         osi_clear_inode(ip);
460         ip->i_state = 0;
461     }
462     AFS_GUNLOCK();
463 }
464 #endif
465
466 /* check_bad_parent() : Checks if this dentry's vcache is a root vcache
467  * that has its mvid (parent dir's fid) pointer set to the wrong directory
468  * due to being mounted in multiple points at once. If so, check_bad_parent()
469  * calls afs_lookup() to correct the vcache's mvid, as well as the volume's
470  * dotdotfid and mtpoint fid members.
471  * Parameters:
472  *  dp - dentry to be checked.
473  * Return Values:
474  *  None.
475  * Sideeffects:
476  *   This dentry's vcache's mvid will be set to the correct parent directory's
477  *   fid.
478  *   This root vnode's volume will have its dotdotfid and mtpoint fids set
479  *    to the correct parent and mountpoint fids.
480  */
481
482 void
483 check_bad_parent(struct dentry *dp)
484 {
485     cred_t *credp;
486     struct vcache *vcp = ITOAFS(dp->d_inode), *avc = NULL;
487     struct vcache *pvc = ITOAFS(dp->d_parent->d_inode);
488
489     if (vcp->mvid->Fid.Volume != pvc->fid.Fid.Volume) { /* bad parent */
490         credp = crref();
491
492
493         /* force a lookup, so vcp->mvid is fixed up */
494         afs_lookup(pvc, dp->d_name.name, &avc, credp);
495         if (!avc || vcp != avc) {       /* bad, very bad.. */
496             afs_Trace4(afs_iclSetp, CM_TRACE_TMP_1S3L, ICL_TYPE_STRING,
497                        "check_bad_parent: bad pointer returned from afs_lookup origvc newvc dentry",
498                        ICL_TYPE_POINTER, vcp, ICL_TYPE_POINTER, avc,
499                        ICL_TYPE_POINTER, dp);
500         }
501         if (avc)
502             AFS_RELE(avc);
503         crfree(credp);
504     }
505     /* if bad parent */
506     return;
507 }
508
509 struct task_struct *rxk_ListenerTask;
510
511 void
512 osi_linux_mask(void)
513 {
514     SIG_LOCK(current);
515     sigfillset(&current->blocked);
516     RECALC_SIGPENDING(current);
517     SIG_UNLOCK(current);
518 }
519
520 void
521 osi_linux_rxkreg(void)
522 {
523     rxk_ListenerTask = current;
524 }