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