v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / fs / jffs2 / file.c
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright (C) 2001 Red Hat, Inc.
5  *
6  * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
7  *
8  * The original JFFS, from which the design for JFFS2 was derived,
9  * was designed and implemented by Axis Communications AB.
10  *
11  * The contents of this file are subject to the Red Hat eCos Public
12  * License Version 1.1 (the "Licence"); you may not use this file
13  * except in compliance with the Licence.  You may obtain a copy of
14  * the Licence at http://www.redhat.com/
15  *
16  * Software distributed under the Licence is distributed on an "AS IS"
17  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
18  * See the Licence for the specific language governing rights and
19  * limitations under the Licence.
20  *
21  * The Original Code is JFFS2 - Journalling Flash File System, version 2
22  *
23  * Alternatively, the contents of this file may be used under the
24  * terms of the GNU General Public License version 2 (the "GPL"), in
25  * which case the provisions of the GPL are applicable instead of the
26  * above.  If you wish to allow the use of your version of this file
27  * only under the terms of the GPL and not to allow others to use your
28  * version of this file under the RHEPL, indicate your decision by
29  * deleting the provisions above and replace them with the notice and
30  * other provisions required by the GPL.  If you do not delete the
31  * provisions above, a recipient may use your version of this file
32  * under either the RHEPL or the GPL.
33  *
34  * $Id: file.c,v 1.55 2001/05/29 09:19:24 dwmw2 Exp $
35  *
36  */
37
38 #include <linux/kernel.h>
39 #include <linux/slab.h>
40 #include <linux/fs.h>
41 #include <linux/pagemap.h>
42 #include <linux/jffs2.h>
43 #include "nodelist.h"
44 #include "crc32.h"
45
46 extern int generic_file_open(struct inode *, struct file *) __attribute__((weak));
47
48
49 int jffs2_null_fsync(struct file *filp, struct dentry *dentry, int datasync)
50 {
51         /* Move along. Nothing to see here */
52         return 0;
53 }
54
55 struct file_operations jffs2_file_operations =
56 {
57         llseek:         generic_file_llseek,
58         open:           generic_file_open,
59         read:           generic_file_read,
60         write:          generic_file_write,
61         ioctl:          jffs2_ioctl,
62         mmap:           generic_file_mmap,
63         fsync:          jffs2_null_fsync
64 };
65
66 /* jffs2_file_inode_operations */
67
68 struct inode_operations jffs2_file_inode_operations =
69 {
70         setattr:        jffs2_setattr
71 };
72
73 struct address_space_operations jffs2_file_address_operations =
74 {
75         readpage:       jffs2_readpage,
76         prepare_write:  jffs2_prepare_write,
77         commit_write:   jffs2_commit_write
78 };
79
80 int jffs2_setattr (struct dentry *dentry, struct iattr *iattr)
81 {
82         struct jffs2_full_dnode *old_metadata, *new_metadata;
83         struct inode *inode = dentry->d_inode;
84         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
85         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
86         struct jffs2_raw_inode *ri;
87         unsigned short dev;
88         unsigned char *mdata = NULL;
89         int mdatalen = 0;
90         unsigned int ivalid;
91         __u32 phys_ofs, alloclen;
92         int ret;
93         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
94         ret = inode_change_ok(inode, iattr);
95         if (ret) 
96                 return ret;
97
98         /* Special cases - we don't want more than one data node
99            for these types on the medium at any time. So setattr
100            must read the original data associated with the node
101            (i.e. the device numbers or the target name) and write
102            it out again with the appropriate data attached */
103         if ((inode->i_mode & S_IFMT) == S_IFBLK ||
104             (inode->i_mode & S_IFMT) == S_IFCHR) {
105                 /* For these, we don't actually need to read the old node */
106                 dev =  (MAJOR(to_kdev_t(dentry->d_inode->i_rdev)) << 8) | 
107                         MINOR(to_kdev_t(dentry->d_inode->i_rdev));
108                 mdata = (char *)&dev;
109                 mdatalen = sizeof(dev);
110                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
111         } else if ((inode->i_mode & S_IFMT) == S_IFLNK) {
112                 mdatalen = f->metadata->size;
113                 mdata = kmalloc(f->metadata->size, GFP_USER);
114                 if (!mdata)
115                         return -ENOMEM;
116                 ret = jffs2_read_dnode(c, f->metadata, mdata, 0, mdatalen);
117                 if (ret) {
118                         kfree(mdata);
119                         return ret;
120                 }
121                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
122         }
123
124         ri = jffs2_alloc_raw_inode();
125         if (!ri) {
126                 if ((inode->i_mode & S_IFMT) == S_IFLNK)
127                         kfree(mdata);
128                 return -ENOMEM;
129         }
130                 
131         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
132         if (ret) {
133                 jffs2_free_raw_inode(ri);
134                 if ((inode->i_mode & S_IFMT) == S_IFLNK)
135                          kfree(mdata);
136                 return ret;
137         }
138         down(&f->sem);
139         ivalid = iattr->ia_valid;
140         
141         ri->magic = JFFS2_MAGIC_BITMASK;
142         ri->nodetype = JFFS2_NODETYPE_INODE;
143         ri->totlen = sizeof(*ri) + mdatalen;
144         ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);
145
146         ri->ino = inode->i_ino;
147         ri->version = ++f->highest_version;
148
149         ri->mode = (ivalid & ATTR_MODE)?iattr->ia_mode:inode->i_mode;
150         ri->uid = (ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid;
151         ri->gid = (ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid;
152
153         if (ivalid & ATTR_MODE && ri->mode & S_ISGID &&
154             !in_group_p(ri->gid) && !capable(CAP_FSETID))
155                 ri->mode &= ~S_ISGID;
156
157         ri->isize = (ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size;
158         ri->atime = (ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime;
159         ri->mtime = (ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime;
160         ri->ctime = (ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime;
161
162         ri->offset = 0;
163         ri->csize = ri->dsize = mdatalen;
164         ri->compr = JFFS2_COMPR_NONE;
165         if (inode->i_size < ri->isize) {
166                 /* It's an extension. Make it a hole node */
167                 ri->compr = JFFS2_COMPR_ZERO;
168                 ri->dsize = ri->isize - inode->i_size;
169                 ri->offset = inode->i_size;
170         }
171         ri->node_crc = crc32(0, ri, sizeof(*ri)-8);
172         if (mdatalen)
173                 ri->data_crc = crc32(0, mdata, mdatalen);
174         else
175                 ri->data_crc = 0;
176
177         new_metadata = jffs2_write_dnode(inode, ri, mdata, mdatalen, phys_ofs, NULL);
178         if ((inode->i_mode & S_IFMT) == S_IFLNK)
179                 kfree(mdata);
180
181         jffs2_complete_reservation(c);
182         
183         if (IS_ERR(new_metadata)) {
184                 jffs2_free_raw_inode(ri);
185                 up(&f->sem);
186                 return PTR_ERR(new_metadata);
187         }
188         /* It worked. Update the inode */
189         inode->i_atime = ri->atime;
190         inode->i_ctime = ri->ctime;
191         inode->i_mtime = ri->mtime;
192         inode->i_mode = ri->mode;
193         inode->i_uid = ri->uid;
194         inode->i_gid = ri->gid;
195
196
197         old_metadata = f->metadata;
198
199         if (inode->i_size > ri->isize) {
200                 vmtruncate(inode, ri->isize);
201                 jffs2_truncate_fraglist (c, &f->fraglist, ri->isize);
202         }
203
204         if (inode->i_size < ri->isize) {
205                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
206                 inode->i_size = ri->isize;
207                 f->metadata = NULL;
208         } else {
209                 f->metadata = new_metadata;
210         }
211         if (old_metadata) {
212                 jffs2_mark_node_obsolete(c, old_metadata->raw);
213                 jffs2_free_full_dnode(old_metadata);
214         }
215         jffs2_free_raw_inode(ri);
216         up(&f->sem);
217         return 0;
218 }
219
220 int jffs2_do_readpage_nolock (struct inode *inode, struct page *pg)
221 {
222         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
223         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
224         struct jffs2_node_frag *frag = f->fraglist;
225         __u32 offset = pg->index << PAGE_CACHE_SHIFT;
226         __u32 end = offset + PAGE_CACHE_SIZE;
227         unsigned char *pg_buf;
228         int ret;
229
230         D1(printk(KERN_DEBUG "jffs2_do_readpage_nolock(): ino #%lu, page at offset 0x%x\n", inode->i_ino, offset));
231
232         if (!PageLocked(pg))
233                 PAGE_BUG(pg);
234
235         while(frag && frag->ofs + frag->size  <= offset) {
236                 //              D1(printk(KERN_DEBUG "skipping frag %d-%d; before the region we care about\n", frag->ofs, frag->ofs + frag->size));
237                 frag = frag->next;
238         }
239
240         pg_buf = kmap(pg);
241
242         /* XXX FIXME: Where a single physical node actually shows up in two
243            frags, we read it twice. Don't do that. */
244         /* Now we're pointing at the first frag which overlaps our page */
245         while(offset < end) {
246                 D2(printk(KERN_DEBUG "jffs2_readpage: offset %d, end %d\n", offset, end));
247                 if (!frag || frag->ofs > offset) {
248                         __u32 holesize = end - offset;
249                         if (frag) {
250                                 D1(printk(KERN_NOTICE "Eep. Hole in ino %ld fraglist. frag->ofs = 0x%08x, offset = 0x%08x\n", inode->i_ino, frag->ofs, offset));
251                                 holesize = min(holesize, frag->ofs - offset);
252                                 D1(jffs2_print_frag_list(f));
253                         }
254                         D1(printk(KERN_DEBUG "Filling non-frag hole from %d-%d\n", offset, offset+holesize));
255                         memset(pg_buf, 0, holesize);
256                         pg_buf += holesize;
257                         offset += holesize;
258                         continue;
259                 } else if (frag->ofs < offset && (offset & (PAGE_CACHE_SIZE-1)) != 0) {
260                         D1(printk(KERN_NOTICE "Eep. Overlap in ino #%ld fraglist. frag->ofs = 0x%08x, offset = 0x%08x\n",
261                                   inode->i_ino, frag->ofs, offset));
262                         D1(jffs2_print_frag_list(f));
263                         memset(pg_buf, 0, end - offset);
264                         ClearPageUptodate(pg);
265                         SetPageError(pg);
266                         kunmap(pg);
267                         return -EIO;
268                 } else if (!frag->node) {
269                         __u32 holeend = min(end, frag->ofs + frag->size);
270                         D1(printk(KERN_DEBUG "Filling frag hole from %d-%d (frag 0x%x 0x%x)\n", offset, holeend, frag->ofs, frag->ofs + frag->size));
271                         memset(pg_buf, 0, holeend - offset);
272                         pg_buf += holeend - offset;
273                         offset = holeend;
274                         frag = frag->next;
275                         continue;
276                 } else {
277                         __u32 readlen;
278                         readlen = min(frag->size, end - offset);
279                         D1(printk(KERN_DEBUG "Reading %d-%d from node at 0x%x\n", frag->ofs, frag->ofs+readlen, frag->node->raw->flash_offset & ~3));
280                         ret = jffs2_read_dnode(c, frag->node, pg_buf, frag->ofs - frag->node->ofs, readlen);
281                         D2(printk(KERN_DEBUG "node read done\n"));
282                         if (ret) {
283                                 D1(printk(KERN_DEBUG"jffs2_readpage error %d\n",ret));
284                                 memset(pg_buf, 0, frag->size);
285                                 ClearPageUptodate(pg);
286                                 SetPageError(pg);
287                                 kunmap(pg);
288                                 return ret;
289                         }
290                 }
291                 pg_buf += frag->size;
292                 offset += frag->size;
293                 frag = frag->next;
294                 D2(printk(KERN_DEBUG "node read was OK. Looping\n"));
295         }
296         D2(printk(KERN_DEBUG "readpage finishing\n"));
297         SetPageUptodate(pg);
298         ClearPageError(pg);
299
300         flush_dcache_page(pg);
301
302         kunmap(pg);
303         D1(printk(KERN_DEBUG "readpage finished\n"));
304         return 0;
305 }
306
307 int jffs2_do_readpage_unlock(struct inode *inode, struct page *pg)
308 {
309         int ret = jffs2_do_readpage_nolock(inode, pg);
310         UnlockPage(pg);
311         return ret;
312 }
313
314
315 int jffs2_readpage (struct file *filp, struct page *pg)
316 {
317         struct jffs2_inode_info *f = JFFS2_INODE_INFO(filp->f_dentry->d_inode);
318         int ret;
319         
320         down(&f->sem);
321         ret = jffs2_do_readpage_unlock(filp->f_dentry->d_inode, pg);
322         up(&f->sem);
323         return ret;
324 }
325
326 int jffs2_prepare_write (struct file *filp, struct page *pg, unsigned start, unsigned end)
327 {
328         struct inode *inode = filp->f_dentry->d_inode;
329         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
330         __u32 pageofs = pg->index << PAGE_CACHE_SHIFT;
331         int ret = 0;
332
333         down(&f->sem);
334         D1(printk(KERN_DEBUG "jffs2_prepare_write() nrpages %ld\n", inode->i_mapping->nrpages));
335
336         if (pageofs > inode->i_size) {
337                 /* Make new hole frag from old EOF to new page */
338                 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
339                 struct jffs2_raw_inode ri;
340                 struct jffs2_full_dnode *fn;
341                 __u32 phys_ofs, alloc_len;
342                 
343                 D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
344                           (unsigned int)inode->i_size, pageofs));
345
346                 ret = jffs2_reserve_space(c, sizeof(ri), &phys_ofs, &alloc_len, ALLOC_NORMAL);
347                 if (ret) {
348                         up(&f->sem);
349                         return ret;
350                 }
351                 memset(&ri, 0, sizeof(ri));
352
353                 ri.magic = JFFS2_MAGIC_BITMASK;
354                 ri.nodetype = JFFS2_NODETYPE_INODE;
355                 ri.totlen = sizeof(ri);
356                 ri.hdr_crc = crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4);
357
358                 ri.ino = f->inocache->ino;
359                 ri.version = ++f->highest_version;
360                 ri.mode = inode->i_mode;
361                 ri.uid = inode->i_uid;
362                 ri.gid = inode->i_gid;
363                 ri.isize = max(inode->i_size, pageofs);
364                 ri.atime = ri.ctime = ri.mtime = CURRENT_TIME;
365                 ri.offset = inode->i_size;
366                 ri.dsize = pageofs - inode->i_size;
367                 ri.csize = 0;
368                 ri.compr = JFFS2_COMPR_ZERO;
369                 ri.node_crc = crc32(0, &ri, sizeof(ri)-8);
370                 ri.data_crc = 0;
371                 
372                 fn = jffs2_write_dnode(inode, &ri, NULL, 0, phys_ofs, NULL);
373                 jffs2_complete_reservation(c);
374                 if (IS_ERR(fn)) {
375                         ret = PTR_ERR(fn);
376                         up(&f->sem);
377                         return ret;
378                 }
379                 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
380                 if (f->metadata) {
381                         jffs2_mark_node_obsolete(c, f->metadata->raw);
382                         jffs2_free_full_dnode(f->metadata);
383                         f->metadata = NULL;
384                 }
385                 if (ret) {
386                         D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in prepare_write, returned %d\n", ret));
387                         jffs2_mark_node_obsolete(c, fn->raw);
388                         jffs2_free_full_dnode(fn);
389                         up(&f->sem);
390                         return ret;
391                 }
392                 inode->i_size = pageofs;
393         }
394         
395
396         /* Read in the page if it wasn't already present */
397         if (!Page_Uptodate(pg) && (start || end < PAGE_SIZE))
398                 ret = jffs2_do_readpage_nolock(inode, pg);
399         D1(printk(KERN_DEBUG "end prepare_write(). nrpages %ld\n", inode->i_mapping->nrpages));
400         up(&f->sem);
401         return ret;
402 }
403
404 int jffs2_commit_write (struct file *filp, struct page *pg, unsigned start, unsigned end)
405 {
406         /* Actually commit the write from the page cache page we're looking at.
407          * For now, we write the full page out each time. It sucks, but it's simple
408          */
409         struct inode *inode = filp->f_dentry->d_inode;
410         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
411         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
412         ssize_t newsize = max(filp->f_dentry->d_inode->i_size, (pg->index << PAGE_CACHE_SHIFT) + end);
413         __u32 file_ofs = (pg->index << PAGE_CACHE_SHIFT);
414         unsigned writelen = min(PAGE_CACHE_SIZE, newsize - file_ofs);
415         struct jffs2_raw_inode *ri;
416         int ret = 0;
417         ssize_t writtenlen = 0;
418
419         D1(printk(KERN_DEBUG "jffs2_commit_write(): ino #%lu, page at 0x%lx, range %d-%d, nrpages %ld\n", inode->i_ino, pg->index << PAGE_CACHE_SHIFT, start, end, filp->f_dentry->d_inode->i_mapping->nrpages));
420
421         ri = jffs2_alloc_raw_inode();
422         if (!ri)
423                 return -ENOMEM;
424
425         while(writelen) {
426                 struct jffs2_full_dnode *fn;
427                 unsigned char *comprbuf = NULL;
428                 unsigned char comprtype = JFFS2_COMPR_NONE;
429                 __u32 phys_ofs, alloclen;
430                 __u32 datalen, cdatalen;
431
432                 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, file_ofs));
433
434                 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL);
435                 if (ret) {
436                         SetPageError(pg);
437                         D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
438                         break;
439                 }
440                 down(&f->sem);
441                 datalen = writelen;
442                 cdatalen = min(alloclen - sizeof(*ri), writelen);
443
444                 comprbuf = kmalloc(cdatalen, GFP_KERNEL);
445                 if (comprbuf) {
446                         comprtype = jffs2_compress(page_address(pg)+ (file_ofs & (PAGE_CACHE_SIZE-1)), comprbuf, &datalen, &cdatalen);
447                 }
448                 if (comprtype == JFFS2_COMPR_NONE) {
449                         /* Either compression failed, or the allocation of comprbuf failed */
450                         if (comprbuf)
451                                 kfree(comprbuf);
452                         comprbuf = page_address(pg) + (file_ofs & (PAGE_CACHE_SIZE -1));
453                         datalen = cdatalen;
454                 }
455                 /* Now comprbuf points to the data to be written, be it compressed or not.
456                    comprtype holds the compression type, and comprtype == JFFS2_COMPR_NONE means
457                    that the comprbuf doesn't need to be kfree()d. 
458                 */
459
460                 ri->magic = JFFS2_MAGIC_BITMASK;
461                 ri->nodetype = JFFS2_NODETYPE_INODE;
462                 ri->totlen = sizeof(*ri) + cdatalen;
463                 ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);
464
465                 ri->ino = inode->i_ino;
466                 ri->version = ++f->highest_version;
467                 ri->mode = inode->i_mode;
468                 ri->uid = inode->i_uid;
469                 ri->gid = inode->i_gid;
470                 ri->isize = max(inode->i_size, file_ofs + datalen);
471                 ri->atime = ri->ctime = ri->mtime = CURRENT_TIME;
472                 ri->offset = file_ofs;
473                 ri->csize = cdatalen;
474                 ri->dsize = datalen;
475                 ri->compr = comprtype;
476                 ri->node_crc = crc32(0, ri, sizeof(*ri)-8);
477                 ri->data_crc = crc32(0, comprbuf, cdatalen);
478
479                 fn = jffs2_write_dnode(inode, ri, comprbuf, cdatalen, phys_ofs, NULL);
480
481                 jffs2_complete_reservation(c);
482
483                 if (comprtype != JFFS2_COMPR_NONE)
484                         kfree(comprbuf);
485
486                 if (IS_ERR(fn)) {
487                         ret = PTR_ERR(fn);
488                         up(&f->sem);
489                         SetPageError(pg);
490                         break;
491                 }
492                 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
493                 if (f->metadata) {
494                         jffs2_mark_node_obsolete(c, f->metadata->raw);
495                         jffs2_free_full_dnode(f->metadata);
496                         f->metadata = NULL;
497                 }
498                 up(&f->sem);
499                 if (ret) {
500                         /* Eep */
501                         D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
502                         jffs2_mark_node_obsolete(c, fn->raw);
503                         jffs2_free_full_dnode(fn);
504                         SetPageError(pg);
505                         break;
506                 }
507                 inode->i_size = ri->isize;
508                 inode->i_blocks = (inode->i_size + 511) >> 9;
509                 inode->i_ctime = inode->i_mtime = ri->ctime;
510                 if (!datalen) {
511                         printk(KERN_WARNING "Eep. We didn't actually write any bloody data\n");
512                         ret = -EIO;
513                         SetPageError(pg);
514                         break;
515                 }
516                 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
517                 writtenlen += datalen;
518                 file_ofs += datalen;
519                 writelen -= datalen;
520         }
521
522         jffs2_free_raw_inode(ri);
523
524         if (writtenlen < end) {
525                 /* generic_file_write has written more to the page cache than we've
526                    actually written to the medium. Mark the page !Uptodate so that 
527                    it gets reread */
528                 D1(printk(KERN_DEBUG "jffs2_commit_write(): Not all bytes written. Marking page !uptodate\n"));
529                 SetPageError(pg);
530                 ClearPageUptodate(pg);
531         }
532         if (writtenlen <= start) {
533                 /* We didn't even get to the start of the affected part */
534                 ret = ret?ret:-ENOSPC;
535                 D1(printk(KERN_DEBUG "jffs2_commit_write(): Only %x bytes written to page. start (%x) not reached, returning %d\n", writtenlen, start, ret));
536         }
537         writtenlen = min(end-start, writtenlen-start);
538
539         D1(printk(KERN_DEBUG "jffs2_commit_write() returning %d. nrpages is %ld\n",writtenlen?writtenlen:ret, inode->i_mapping->nrpages));
540         return writtenlen?writtenlen:ret;
541 }