DEVEL15-linux-warning-reduction-20090318
[openafs.git] / src / afs / LINUX / osi_file.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 #include <afsconfig.h>
11 #include "afs/param.h"
12
13 RCSID
14     ("$Header$");
15
16 #ifdef AFS_LINUX24_ENV
17 #include "h/module.h" /* early to avoid printf->printk mapping */
18 #endif
19 #include "afs/sysincludes.h"    /* Standard vendor system headers */
20 #include "afsincludes.h"        /* Afs-based standard headers */
21 #include "afs/afs_stats.h"      /* afs statistics */
22 #include "h/smp_lock.h"
23 #if defined(AFS_LINUX26_ENV)
24 #include "h/namei.h"
25 #endif
26 #if !defined(HAVE_IGET)
27 #include "h/exportfs.h"
28 #endif
29
30 afs_lock_t afs_xosi;            /* lock is for tvattr */
31 extern struct osi_dev cacheDev;
32 #if defined(AFS_LINUX24_ENV)
33 extern struct vfsmount *afs_cacheMnt;
34 #endif
35 extern struct super_block *afs_cacheSBp;
36
37 #if defined(AFS_LINUX26_ENV) 
38 void *
39 #if defined(LINUX_USE_FH)
40 osi_UFSOpen_fh(struct fid *fh, int fh_type)
41 #else
42 osi_UFSOpen(afs_int32 ainode)
43 #endif
44 {
45     register struct osi_file *afile = NULL;
46     extern int cacheDiskType;
47     struct inode *tip = NULL;
48     struct dentry *dp = NULL;
49     struct file *filp = NULL;
50 #if !defined(HAVE_IGET) || defined(LINUX_USE_FH)
51     struct fid fid;
52 #endif
53     AFS_STATCNT(osi_UFSOpen);
54     if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
55         osi_Panic("UFSOpen called for non-UFS cache\n");
56     }
57     if (!afs_osicred_initialized) {
58         /* valid for alpha_osf, SunOS, Ultrix */
59         memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
60         crhold(&afs_osi_cred);  /* don't let it evaporate, since it is static */
61         afs_osicred_initialized = 1;
62     }
63     afile = (struct osi_file *)osi_AllocLargeSpace(sizeof(struct osi_file));
64     AFS_GUNLOCK();
65     if (!afile) {
66         osi_Panic("osi_UFSOpen: Failed to allocate %d bytes for osi_file.\n",
67                   (int)sizeof(struct osi_file));
68     }
69     memset(afile, 0, sizeof(struct osi_file));
70 #if defined(HAVE_IGET)
71     tip = iget(afs_cacheSBp, (u_long) ainode);
72     if (!tip)
73         osi_Panic("Can't get inode %d\n", ainode);
74
75     dp = d_alloc_anon(tip);
76 #else
77 #if defined(LINUX_USE_FH)
78     dp = afs_cacheSBp->s_export_op->fh_to_dentry(afs_cacheSBp, fh, sizeof(struct fid), fh_type);
79 #else
80     fid.i32.ino = ainode;
81     fid.i32.gen = 0;
82     dp = afs_cacheSBp->s_export_op->fh_to_dentry(afs_cacheSBp, &fid, sizeof(fid), FILEID_INO32_GEN);
83 #endif
84     if (!dp) 
85            osi_Panic("Can't get dentry\n");          
86     tip = dp->d_inode;
87 #endif
88     tip->i_flags |= MS_NOATIME; /* Disable updating access times. */
89
90 #if defined(STRUCT_TASK_HAS_CRED)
91     filp = dentry_open(dp, mntget(afs_cacheMnt), O_RDWR, current_cred());
92 #else
93     filp = dentry_open(dp, mntget(afs_cacheMnt), O_RDWR);
94 #endif
95     if (IS_ERR(filp))
96 #if defined(LINUX_USE_FH)
97         osi_Panic("Can't open file\n");
98 #else
99         osi_Panic("Can't open inode %d\n", ainode);
100 #endif
101     afile->filp = filp;
102     afile->size = i_size_read(FILE_INODE(filp));
103     AFS_GLOCK();
104     afile->offset = 0;
105     afile->proc = (int (*)())0;
106 #if defined(LINUX_USE_FH)
107     afile->inum = tip->i_ino;   /* for hint validity checking */
108 #else
109     afile->inum = ainode;       /* for hint validity checking */
110 #endif
111     return (void *)afile;
112 }
113 #else
114 void *
115 osi_UFSOpen(afs_int32 ainode)
116 {
117     register struct osi_file *afile = NULL;
118     extern int cacheDiskType;
119     afs_int32 code = 0;
120     struct inode *tip = NULL;
121     struct file *filp = NULL;
122     AFS_STATCNT(osi_UFSOpen);
123     if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
124         osi_Panic("UFSOpen called for non-UFS cache\n");
125     }
126     if (!afs_osicred_initialized) {
127         /* valid for alpha_osf, SunOS, Ultrix */
128         memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
129         crhold(&afs_osi_cred);  /* don't let it evaporate, since it is static */
130         afs_osicred_initialized = 1;
131     }
132     afile = (struct osi_file *)osi_AllocLargeSpace(sizeof(struct osi_file));
133     AFS_GUNLOCK();
134     if (!afile) {
135         osi_Panic("osi_UFSOpen: Failed to allocate %d bytes for osi_file.\n",
136                   sizeof(struct osi_file));
137     }
138     memset(afile, 0, sizeof(struct osi_file));
139     filp = &afile->file;
140     filp->f_dentry = &afile->dentry;
141     tip = iget(afs_cacheSBp, (u_long) ainode);
142     if (!tip)
143         osi_Panic("Can't get inode %d\n", ainode);
144     FILE_INODE(filp) = tip;
145     tip->i_flags |= MS_NOATIME; /* Disable updating access times. */
146     filp->f_flags = O_RDWR;
147 #if defined(AFS_LINUX24_ENV)
148     filp->f_mode = FMODE_READ|FMODE_WRITE;
149     filp->f_op = fops_get(tip->i_fop);
150 #else
151     filp->f_op = tip->i_op->default_file_ops;
152 #endif
153     if (filp->f_op && filp->f_op->open)
154         code = filp->f_op->open(tip, filp);
155     if (code)
156         osi_Panic("Can't open inode %d\n", ainode);
157     afile->size = i_size_read(tip);
158     AFS_GLOCK();
159     afile->offset = 0;
160     afile->proc = (int (*)())0;
161     afile->inum = ainode;       /* for hint validity checking */
162     return (void *)afile;
163 }
164 #endif
165
166 #if defined(LINUX_USE_FH)
167 int
168 osi_get_fh(struct dentry *dp, struct fid *fh, int *max_len) {
169     int fh_type;
170
171     if (dp->d_sb->s_export_op->encode_fh) {
172            fh_type = dp->d_sb->s_export_op->encode_fh(dp, (__u32 *)fh, max_len, 0);
173     } else {
174            fh_type = FILEID_INO32_GEN;
175            fh->i32.ino = dp->d_inode->i_ino;
176            fh->i32.gen = dp->d_inode->i_generation;
177     }
178     dput(dp);
179     return(fh_type);
180 }
181 #endif
182
183 int
184 afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
185 {
186     register afs_int32 code;
187     AFS_STATCNT(osi_Stat);
188     MObtainWriteLock(&afs_xosi, 320);
189     astat->size = i_size_read(OSIFILE_INODE(afile));
190 #if defined(AFS_LINUX26_ENV)
191     astat->mtime = OSIFILE_INODE(afile)->i_mtime.tv_sec;
192     astat->atime = OSIFILE_INODE(afile)->i_atime.tv_sec;
193 #else
194     astat->mtime = OSIFILE_INODE(afile)->i_mtime;
195     astat->atime = OSIFILE_INODE(afile)->i_atime;
196 #endif
197     code = 0;
198     MReleaseWriteLock(&afs_xosi);
199     return code;
200 }
201
202 #ifdef AFS_LINUX26_ENV
203 int
204 osi_UFSClose(register struct osi_file *afile)
205 {
206     AFS_STATCNT(osi_Close);
207     if (afile) {
208         if (OSIFILE_INODE(afile)) {
209             filp_close(afile->filp, NULL);
210         }
211     }
212
213     osi_FreeLargeSpace(afile);
214     return 0;
215 }
216 #else
217 int
218 osi_UFSClose(register struct osi_file *afile)
219 {
220     AFS_STATCNT(osi_Close);
221     if (afile) {
222         if (FILE_INODE(&afile->file)) {
223             struct file *filp = &afile->file;
224             if (filp->f_op && filp->f_op->release)
225                 filp->f_op->release(FILE_INODE(filp), filp);
226             iput(FILE_INODE(filp));
227         }
228     }
229
230     osi_FreeLargeSpace(afile);
231     return 0;
232 }
233 #endif
234
235 int
236 osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
237 {
238     register afs_int32 code;
239     struct osi_stat tstat;
240     struct iattr newattrs;
241     struct inode *inode = OSIFILE_INODE(afile);
242     AFS_STATCNT(osi_Truncate);
243
244     /* This routine only shrinks files, and most systems
245      * have very slow truncates, even when the file is already
246      * small enough.  Check now and save some time.
247      */
248     code = afs_osi_Stat(afile, &tstat);
249     if (code || tstat.size <= asize)
250         return code;
251     MObtainWriteLock(&afs_xosi, 321);
252     AFS_GUNLOCK();
253 #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
254     down_write(&inode->i_alloc_sem);
255 #endif
256 #ifdef STRUCT_INODE_HAS_I_MUTEX
257     mutex_lock(&inode->i_mutex);
258 #else
259     down(&inode->i_sem);
260 #endif
261     newattrs.ia_size = asize;
262     newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
263 #if defined(AFS_LINUX24_ENV)
264     newattrs.ia_ctime = CURRENT_TIME;
265
266     /* avoid notify_change() since it wants to update dentry->d_parent */
267     lock_kernel();
268     code = inode_change_ok(inode, &newattrs);
269     if (!code)
270 #ifdef INODE_SETATTR_NOT_VOID
271         code = inode_setattr(inode, &newattrs);
272 #else
273         inode_setattr(inode, &newattrs);
274 #endif
275     unlock_kernel();
276     if (!code)
277         truncate_inode_pages(&inode->i_data, asize);
278 #else
279     i_size_write(inode, asize);
280     if (inode->i_sb->s_op && inode->i_sb->s_op->notify_change) {
281         code = inode->i_sb->s_op->notify_change(&afile->dentry, &newattrs);
282     }
283     if (!code) {
284         truncate_inode_pages(inode, asize);
285         if (inode->i_op && inode->i_op->truncate)
286             inode->i_op->truncate(inode);
287     }
288 #endif
289     code = -code;
290 #ifdef STRUCT_INODE_HAS_I_MUTEX
291     mutex_unlock(&inode->i_mutex);
292 #else
293     up(&inode->i_sem);
294 #endif
295 #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
296     up_write(&inode->i_alloc_sem);
297 #endif
298     AFS_GLOCK();
299     MReleaseWriteLock(&afs_xosi);
300     return code;
301 }
302
303
304 /* Generic read interface */
305 int
306 afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
307              afs_int32 asize)
308 {
309     struct uio auio;
310     struct iovec iov;
311     afs_int32 code;
312
313     AFS_STATCNT(osi_Read);
314
315     /*
316      * If the osi_file passed in is NULL, panic only if AFS is not shutting
317      * down. No point in crashing when we are already shutting down
318      */
319     if (!afile) {
320         if (!afs_shuttingdown)
321             osi_Panic("osi_Read called with null param");
322         else
323             return EIO;
324     }
325
326     if (offset != -1)
327         afile->offset = offset;
328     setup_uio(&auio, &iov, aptr, afile->offset, asize, UIO_READ, AFS_UIOSYS);
329     AFS_GUNLOCK();
330     code = osi_rdwr(afile, &auio, UIO_READ);
331     AFS_GLOCK();
332     if (code == 0) {
333         code = asize - auio.uio_resid;
334         afile->offset += code;
335     } else {
336         afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, auio.uio_resid,
337                    ICL_TYPE_INT32, code);
338         code = -1;
339     }
340     return code;
341 }
342
343 /* Generic write interface */
344 int
345 afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
346               afs_int32 asize)
347 {
348     struct uio auio;
349     struct iovec iov;
350     afs_int32 code;
351
352     AFS_STATCNT(osi_Write);
353
354     if (!afile) {
355         if (!afs_shuttingdown)
356             osi_Panic("afs_osi_Write called with null param");
357         else
358             return EIO;
359     }
360
361     if (offset != -1)
362         afile->offset = offset;
363     setup_uio(&auio, &iov, aptr, afile->offset, asize, UIO_WRITE, AFS_UIOSYS);
364     AFS_GUNLOCK();
365     code = osi_rdwr(afile, &auio, UIO_WRITE);
366     AFS_GLOCK();
367     if (code == 0) {
368         code = asize - auio.uio_resid;
369         afile->offset += code;
370     } else {
371         if (code == ENOSPC)
372             afs_warnuser
373                 ("\n\n\n*** Cache partition is FULL - Decrease cachesize!!! ***\n\n");
374         code = -1;
375     }
376
377     if (afile->proc)
378         (*afile->proc)(afile, code);
379
380     return code;
381 }
382
383
384 /*  This work should be handled by physstrat in ca/machdep.c.
385     This routine written from the RT NFS port strategy routine.
386     It has been generalized a bit, but should still be pretty clear. */
387 int
388 afs_osi_MapStrategy(int (*aproc) (struct buf * bp), register struct buf *bp)
389 {
390     afs_int32 returnCode;
391
392     AFS_STATCNT(osi_MapStrategy);
393     returnCode = (*aproc) (bp);
394
395     return returnCode;
396 }
397
398 void
399 shutdown_osifile(void)
400 {
401     AFS_STATCNT(shutdown_osifile);
402     if (afs_cold_shutdown) {
403         afs_osicred_initialized = 0;
404     }
405 }
406
407 /* Intialize cache device info and fragment size for disk cache partition. */
408 int
409 osi_InitCacheInfo(char *aname)
410 {
411     int code;
412 #if defined(LINUX_USE_FH)
413     int max_len = sizeof(struct fid);
414 #else
415     extern ino_t cacheInode;
416 #endif
417     struct dentry *dp;
418     extern ino_t cacheInode;
419     extern struct osi_dev cacheDev;
420     extern afs_int32 afs_fsfragsize;
421     extern struct super_block *afs_cacheSBp;
422     extern struct vfsmount *afs_cacheMnt;
423     code = osi_lookupname_internal(aname, 1, &afs_cacheMnt, &dp);
424     if (code)
425         return ENOENT;
426
427 #if defined(LINUX_USE_FH)
428     if (dp->d_sb->s_export_op->encode_fh) {
429         cacheitems_fh_type = dp->d_sb->s_export_op->encode_fh(dp, (__u32 *)&cacheitems_fh, &max_len, 0);
430     } else {
431         cacheitems_fh_type = FILEID_INO32_GEN;
432         cacheitems_fh.i32.ino = dp->d_inode->i_ino;
433         cacheitems_fh.i32.gen = dp->d_inode->i_generation;
434     }
435 #else
436     cacheInode = dp->d_inode->i_ino;
437 #endif
438     cacheDev.dev = dp->d_inode->i_sb->s_dev;
439     afs_fsfragsize = dp->d_inode->i_sb->s_blocksize - 1;
440     afs_cacheSBp = dp->d_inode->i_sb;
441
442     dput(dp);
443
444     return 0;
445 }
446
447
448 #define FOP_READ(F, B, C) (F)->f_op->read(F, B, (size_t)(C), &(F)->f_pos)
449 #define FOP_WRITE(F, B, C) (F)->f_op->write(F, B, (size_t)(C), &(F)->f_pos)
450
451 /* osi_rdwr
452  * seek, then read or write to an open inode. addrp points to data in
453  * kernel space.
454  */
455 int
456 osi_rdwr(struct osi_file *osifile, uio_t * uiop, int rw)
457 {
458 #ifdef AFS_LINUX26_ENV
459     struct file *filp = osifile->filp;
460 #else
461     struct file *filp = &osifile->file;
462 #endif
463     KERNEL_SPACE_DECL;
464     int code = 0;
465     struct iovec *iov;
466     afs_size_t count;
467     unsigned long savelim;
468
469     savelim = current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur;
470     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
471
472     if (uiop->uio_seg == AFS_UIOSYS)
473         TO_USER_SPACE();
474
475     /* seek to the desired position. Return -1 on error. */
476     if (filp->f_op->llseek) {
477         if (filp->f_op->llseek(filp, (loff_t) uiop->uio_offset, 0) != uiop->uio_offset)
478             return -1;
479     } else
480         filp->f_pos = uiop->uio_offset;
481
482     while (code == 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
483         iov = uiop->uio_iov;
484         count = iov->iov_len;
485         if (count == 0) {
486             uiop->uio_iov++;
487             uiop->uio_iovcnt--;
488             continue;
489         }
490
491         if (rw == UIO_READ)
492             code = FOP_READ(filp, iov->iov_base, count);
493         else
494             code = FOP_WRITE(filp, iov->iov_base, count);
495
496         if (code < 0) {
497             code = -code;
498             break;
499         } else if (code == 0) {
500             /*
501              * This is bad -- we can't read any more data from the
502              * file, but we have no good way of signaling a partial
503              * read either.
504              */
505             code = EIO;
506             break;
507         }
508
509         iov->iov_base += code;
510         iov->iov_len -= code;
511         uiop->uio_resid -= code;
512         uiop->uio_offset += code;
513         code = 0;
514     }
515
516     if (uiop->uio_seg == AFS_UIOSYS)
517         TO_KERNEL_SPACE();
518
519     current->TASK_STRUCT_RLIM[RLIMIT_FSIZE].rlim_cur = savelim;
520
521     return code;
522 }
523
524 /* setup_uio 
525  * Setup a uio struct.
526  */
527 void
528 setup_uio(uio_t * uiop, struct iovec *iovecp, const char *buf, afs_offs_t pos,
529           int count, uio_flag_t flag, uio_seg_t seg)
530 {
531     iovecp->iov_base = (char *)buf;
532     iovecp->iov_len = count;
533     uiop->uio_iov = iovecp;
534     uiop->uio_iovcnt = 1;
535     uiop->uio_offset = pos;
536     uiop->uio_seg = seg;
537     uiop->uio_resid = count;
538     uiop->uio_flag = flag;
539 }
540
541
542 /* uiomove
543  * UIO_READ : dp -> uio
544  * UIO_WRITE : uio -> dp
545  */
546 int
547 uiomove(char *dp, int length, uio_flag_t rw, uio_t * uiop)
548 {
549     int count;
550     struct iovec *iov;
551     int code;
552
553     while (length > 0 && uiop->uio_resid > 0 && uiop->uio_iovcnt > 0) {
554         iov = uiop->uio_iov;
555         count = iov->iov_len;
556
557         if (!count) {
558             uiop->uio_iov++;
559             uiop->uio_iovcnt--;
560             continue;
561         }
562
563         if (count > length)
564             count = length;
565
566         switch (uiop->uio_seg) {
567         case AFS_UIOSYS:
568             switch (rw) {
569             case UIO_READ:
570                 memcpy(iov->iov_base, dp, count);
571                 break;
572             case UIO_WRITE:
573                 memcpy(dp, iov->iov_base, count);
574                 break;
575             default:
576                 printf("uiomove: Bad rw = %d\n", rw);
577                 return -EINVAL;
578             }
579             break;
580         case AFS_UIOUSER:
581             switch (rw) {
582             case UIO_READ:
583                 AFS_COPYOUT(dp, iov->iov_base, count, code);
584                 break;
585             case UIO_WRITE:
586                 AFS_COPYIN(iov->iov_base, dp, count, code);
587                 break;
588             default:
589                 printf("uiomove: Bad rw = %d\n", rw);
590                 return -EINVAL;
591             }
592             break;
593         default:
594             printf("uiomove: Bad seg = %d\n", uiop->uio_seg);
595             return -EINVAL;
596         }
597
598         dp += count;
599         length -= count;
600         iov->iov_base += count;
601         iov->iov_len -= count;
602         uiop->uio_offset += count;
603         uiop->uio_resid -= count;
604     }
605     return 0;
606 }
607