~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/jffs2/fs.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * JFFS2 -- Journalling Flash File System, Version 2.
  3  *
  4  * Copyright © 2001-2007 Red Hat, Inc.
  5  * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
  6  *
  7  * Created by David Woodhouse <dwmw2@infradead.org>
  8  *
  9  * For licensing information, see the file 'LICENCE' in this directory.
 10  *
 11  */
 12 
 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 14 
 15 #include <linux/capability.h>
 16 #include <linux/kernel.h>
 17 #include <linux/sched.h>
 18 #include <linux/fs.h>
 19 #include <linux/list.h>
 20 #include <linux/mtd/mtd.h>
 21 #include <linux/pagemap.h>
 22 #include <linux/slab.h>
 23 #include <linux/vmalloc.h>
 24 #include <linux/vfs.h>
 25 #include <linux/crc32.h>
 26 #include "nodelist.h"
 27 
 28 static int jffs2_flash_setup(struct jffs2_sb_info *c);
 29 
 30 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
 31 {
 32         struct jffs2_full_dnode *old_metadata, *new_metadata;
 33         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 34         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 35         struct jffs2_raw_inode *ri;
 36         union jffs2_device_node dev;
 37         unsigned char *mdata = NULL;
 38         int mdatalen = 0;
 39         unsigned int ivalid;
 40         uint32_t alloclen;
 41         int ret;
 42         int alloc_type = ALLOC_NORMAL;
 43 
 44         jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
 45 
 46         /* Special cases - we don't want more than one data node
 47            for these types on the medium at any time. So setattr
 48            must read the original data associated with the node
 49            (i.e. the device numbers or the target name) and write
 50            it out again with the appropriate data attached */
 51         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
 52                 /* For these, we don't actually need to read the old node */
 53                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
 54                 mdata = (char *)&dev;
 55                 jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
 56                           __func__, mdatalen);
 57         } else if (S_ISLNK(inode->i_mode)) {
 58                 mutex_lock(&f->sem);
 59                 mdatalen = f->metadata->size;
 60                 mdata = kmalloc(f->metadata->size, GFP_USER);
 61                 if (!mdata) {
 62                         mutex_unlock(&f->sem);
 63                         return -ENOMEM;
 64                 }
 65                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
 66                 if (ret) {
 67                         mutex_unlock(&f->sem);
 68                         kfree(mdata);
 69                         return ret;
 70                 }
 71                 mutex_unlock(&f->sem);
 72                 jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
 73                           __func__, mdatalen);
 74         }
 75 
 76         ri = jffs2_alloc_raw_inode();
 77         if (!ri) {
 78                 if (S_ISLNK(inode->i_mode))
 79                         kfree(mdata);
 80                 return -ENOMEM;
 81         }
 82 
 83         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
 84                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
 85         if (ret) {
 86                 jffs2_free_raw_inode(ri);
 87                 if (S_ISLNK(inode->i_mode))
 88                          kfree(mdata);
 89                 return ret;
 90         }
 91         mutex_lock(&f->sem);
 92         ivalid = iattr->ia_valid;
 93 
 94         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 95         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
 96         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
 97         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
 98 
 99         ri->ino = cpu_to_je32(inode->i_ino);
100         ri->version = cpu_to_je32(++f->highest_version);
101 
102         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
103                 from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
104         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
105                 from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
106 
107         if (ivalid & ATTR_MODE)
108                 ri->mode = cpu_to_jemode(iattr->ia_mode);
109         else
110                 ri->mode = cpu_to_jemode(inode->i_mode);
111 
112 
113         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
114         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
115         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
116         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
117 
118         ri->offset = cpu_to_je32(0);
119         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
120         ri->compr = JFFS2_COMPR_NONE;
121         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
122                 /* It's an extension. Make it a hole node */
123                 ri->compr = JFFS2_COMPR_ZERO;
124                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
125                 ri->offset = cpu_to_je32(inode->i_size);
126         } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
127                 /* For truncate-to-zero, treat it as deletion because
128                    it'll always be obsoleting all previous nodes */
129                 alloc_type = ALLOC_DELETION;
130         }
131         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
132         if (mdatalen)
133                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
134         else
135                 ri->data_crc = cpu_to_je32(0);
136 
137         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
138         if (S_ISLNK(inode->i_mode))
139                 kfree(mdata);
140 
141         if (IS_ERR(new_metadata)) {
142                 jffs2_complete_reservation(c);
143                 jffs2_free_raw_inode(ri);
144                 mutex_unlock(&f->sem);
145                 return PTR_ERR(new_metadata);
146         }
147         /* It worked. Update the inode */
148         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
149         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
150         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
151         inode->i_mode = jemode_to_cpu(ri->mode);
152         i_uid_write(inode, je16_to_cpu(ri->uid));
153         i_gid_write(inode, je16_to_cpu(ri->gid));
154 
155 
156         old_metadata = f->metadata;
157 
158         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
159                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
160 
161         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
162                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
163                 inode->i_size = iattr->ia_size;
164                 inode->i_blocks = (inode->i_size + 511) >> 9;
165                 f->metadata = NULL;
166         } else {
167                 f->metadata = new_metadata;
168         }
169         if (old_metadata) {
170                 jffs2_mark_node_obsolete(c, old_metadata->raw);
171                 jffs2_free_full_dnode(old_metadata);
172         }
173         jffs2_free_raw_inode(ri);
174 
175         mutex_unlock(&f->sem);
176         jffs2_complete_reservation(c);
177 
178         /* We have to do the truncate_setsize() without f->sem held, since
179            some pages may be locked and waiting for it in readpage().
180            We are protected from a simultaneous write() extending i_size
181            back past iattr->ia_size, because do_truncate() holds the
182            generic inode semaphore. */
183         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
184                 truncate_setsize(inode, iattr->ia_size);
185                 inode->i_blocks = (inode->i_size + 511) >> 9;
186         }       
187 
188         return 0;
189 }
190 
191 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
192 {
193         int rc;
194 
195         rc = inode_change_ok(dentry->d_inode, iattr);
196         if (rc)
197                 return rc;
198 
199         rc = jffs2_do_setattr(dentry->d_inode, iattr);
200         if (!rc && (iattr->ia_valid & ATTR_MODE))
201                 rc = jffs2_acl_chmod(dentry->d_inode);
202 
203         return rc;
204 }
205 
206 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
207 {
208         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
209         unsigned long avail;
210 
211         buf->f_type = JFFS2_SUPER_MAGIC;
212         buf->f_bsize = 1 << PAGE_SHIFT;
213         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
214         buf->f_files = 0;
215         buf->f_ffree = 0;
216         buf->f_namelen = JFFS2_MAX_NAME_LEN;
217         buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
218         buf->f_fsid.val[1] = c->mtd->index;
219 
220         spin_lock(&c->erase_completion_lock);
221         avail = c->dirty_size + c->free_size;
222         if (avail > c->sector_size * c->resv_blocks_write)
223                 avail -= c->sector_size * c->resv_blocks_write;
224         else
225                 avail = 0;
226         spin_unlock(&c->erase_completion_lock);
227 
228         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
229 
230         return 0;
231 }
232 
233 
234 void jffs2_evict_inode (struct inode *inode)
235 {
236         /* We can forget about this inode for now - drop all
237          *  the nodelists associated with it, etc.
238          */
239         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
240         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
241 
242         jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
243                   __func__, inode->i_ino, inode->i_mode);
244         truncate_inode_pages(&inode->i_data, 0);
245         clear_inode(inode);
246         jffs2_do_clear_inode(c, f);
247 }
248 
249 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
250 {
251         struct jffs2_inode_info *f;
252         struct jffs2_sb_info *c;
253         struct jffs2_raw_inode latest_node;
254         union jffs2_device_node jdev;
255         struct inode *inode;
256         dev_t rdev = 0;
257         int ret;
258 
259         jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
260 
261         inode = iget_locked(sb, ino);
262         if (!inode)
263                 return ERR_PTR(-ENOMEM);
264         if (!(inode->i_state & I_NEW))
265                 return inode;
266 
267         f = JFFS2_INODE_INFO(inode);
268         c = JFFS2_SB_INFO(inode->i_sb);
269 
270         jffs2_init_inode_info(f);
271         mutex_lock(&f->sem);
272 
273         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
274 
275         if (ret) {
276                 mutex_unlock(&f->sem);
277                 iget_failed(inode);
278                 return ERR_PTR(ret);
279         }
280         inode->i_mode = jemode_to_cpu(latest_node.mode);
281         i_uid_write(inode, je16_to_cpu(latest_node.uid));
282         i_gid_write(inode, je16_to_cpu(latest_node.gid));
283         inode->i_size = je32_to_cpu(latest_node.isize);
284         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
285         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
286         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
287 
288         set_nlink(inode, f->inocache->pino_nlink);
289 
290         inode->i_blocks = (inode->i_size + 511) >> 9;
291 
292         switch (inode->i_mode & S_IFMT) {
293 
294         case S_IFLNK:
295                 inode->i_op = &jffs2_symlink_inode_operations;
296                 break;
297 
298         case S_IFDIR:
299         {
300                 struct jffs2_full_dirent *fd;
301                 set_nlink(inode, 2); /* parent and '.' */
302 
303                 for (fd=f->dents; fd; fd = fd->next) {
304                         if (fd->type == DT_DIR && fd->ino)
305                                 inc_nlink(inode);
306                 }
307                 /* Root dir gets i_nlink 3 for some reason */
308                 if (inode->i_ino == 1)
309                         inc_nlink(inode);
310 
311                 inode->i_op = &jffs2_dir_inode_operations;
312                 inode->i_fop = &jffs2_dir_operations;
313                 break;
314         }
315         case S_IFREG:
316                 inode->i_op = &jffs2_file_inode_operations;
317                 inode->i_fop = &jffs2_file_operations;
318                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
319                 inode->i_mapping->nrpages = 0;
320                 break;
321 
322         case S_IFBLK:
323         case S_IFCHR:
324                 /* Read the device numbers from the media */
325                 if (f->metadata->size != sizeof(jdev.old_id) &&
326                     f->metadata->size != sizeof(jdev.new_id)) {
327                         pr_notice("Device node has strange size %d\n",
328                                   f->metadata->size);
329                         goto error_io;
330                 }
331                 jffs2_dbg(1, "Reading device numbers from flash\n");
332                 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
333                 if (ret < 0) {
334                         /* Eep */
335                         pr_notice("Read device numbers for inode %lu failed\n",
336                                   (unsigned long)inode->i_ino);
337                         goto error;
338                 }
339                 if (f->metadata->size == sizeof(jdev.old_id))
340                         rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
341                 else
342                         rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
343 
344         case S_IFSOCK:
345         case S_IFIFO:
346                 inode->i_op = &jffs2_file_inode_operations;
347                 init_special_inode(inode, inode->i_mode, rdev);
348                 break;
349 
350         default:
351                 pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
352                         __func__, inode->i_mode, (unsigned long)inode->i_ino);
353         }
354 
355         mutex_unlock(&f->sem);
356 
357         jffs2_dbg(1, "jffs2_read_inode() returning\n");
358         unlock_new_inode(inode);
359         return inode;
360 
361 error_io:
362         ret = -EIO;
363 error:
364         mutex_unlock(&f->sem);
365         jffs2_do_clear_inode(c, f);
366         iget_failed(inode);
367         return ERR_PTR(ret);
368 }
369 
370 void jffs2_dirty_inode(struct inode *inode, int flags)
371 {
372         struct iattr iattr;
373 
374         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
375                 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
376                           __func__, inode->i_ino);
377                 return;
378         }
379 
380         jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
381                   __func__, inode->i_ino);
382 
383         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
384         iattr.ia_mode = inode->i_mode;
385         iattr.ia_uid = inode->i_uid;
386         iattr.ia_gid = inode->i_gid;
387         iattr.ia_atime = inode->i_atime;
388         iattr.ia_mtime = inode->i_mtime;
389         iattr.ia_ctime = inode->i_ctime;
390 
391         jffs2_do_setattr(inode, &iattr);
392 }
393 
394 int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
395 {
396         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
397 
398         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
399                 return -EROFS;
400 
401         /* We stop if it was running, then restart if it needs to.
402            This also catches the case where it was stopped and this
403            is just a remount to restart it.
404            Flush the writebuffer, if neccecary, else we loose it */
405         if (!(sb->s_flags & MS_RDONLY)) {
406                 jffs2_stop_garbage_collect_thread(c);
407                 mutex_lock(&c->alloc_sem);
408                 jffs2_flush_wbuf_pad(c);
409                 mutex_unlock(&c->alloc_sem);
410         }
411 
412         if (!(*flags & MS_RDONLY))
413                 jffs2_start_garbage_collect_thread(c);
414 
415         *flags |= MS_NOATIME;
416         return 0;
417 }
418 
419 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
420    fill in the raw_inode while you're at it. */
421 struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
422 {
423         struct inode *inode;
424         struct super_block *sb = dir_i->i_sb;
425         struct jffs2_sb_info *c;
426         struct jffs2_inode_info *f;
427         int ret;
428 
429         jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
430                   __func__, dir_i->i_ino, mode);
431 
432         c = JFFS2_SB_INFO(sb);
433 
434         inode = new_inode(sb);
435 
436         if (!inode)
437                 return ERR_PTR(-ENOMEM);
438 
439         f = JFFS2_INODE_INFO(inode);
440         jffs2_init_inode_info(f);
441         mutex_lock(&f->sem);
442 
443         memset(ri, 0, sizeof(*ri));
444         /* Set OS-specific defaults for new inodes */
445         ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid()));
446 
447         if (dir_i->i_mode & S_ISGID) {
448                 ri->gid = cpu_to_je16(i_gid_read(dir_i));
449                 if (S_ISDIR(mode))
450                         mode |= S_ISGID;
451         } else {
452                 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid()));
453         }
454 
455         /* POSIX ACLs have to be processed now, at least partly.
456            The umask is only applied if there's no default ACL */
457         ret = jffs2_init_acl_pre(dir_i, inode, &mode);
458         if (ret) {
459             make_bad_inode(inode);
460             iput(inode);
461             return ERR_PTR(ret);
462         }
463         ret = jffs2_do_new_inode (c, f, mode, ri);
464         if (ret) {
465                 make_bad_inode(inode);
466                 iput(inode);
467                 return ERR_PTR(ret);
468         }
469         set_nlink(inode, 1);
470         inode->i_ino = je32_to_cpu(ri->ino);
471         inode->i_mode = jemode_to_cpu(ri->mode);
472         i_gid_write(inode, je16_to_cpu(ri->gid));
473         i_uid_write(inode, je16_to_cpu(ri->uid));
474         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
475         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
476 
477         inode->i_blocks = 0;
478         inode->i_size = 0;
479 
480         if (insert_inode_locked(inode) < 0) {
481                 make_bad_inode(inode);
482                 iput(inode);
483                 return ERR_PTR(-EINVAL);
484         }
485 
486         return inode;
487 }
488 
489 static int calculate_inocache_hashsize(uint32_t flash_size)
490 {
491         /*
492          * Pick a inocache hash size based on the size of the medium.
493          * Count how many megabytes we're dealing with, apply a hashsize twice
494          * that size, but rounding down to the usual big powers of 2. And keep
495          * to sensible bounds.
496          */
497 
498         int size_mb = flash_size / 1024 / 1024;
499         int hashsize = (size_mb * 2) & ~0x3f;
500 
501         if (hashsize < INOCACHE_HASHSIZE_MIN)
502                 return INOCACHE_HASHSIZE_MIN;
503         if (hashsize > INOCACHE_HASHSIZE_MAX)
504                 return INOCACHE_HASHSIZE_MAX;
505 
506         return hashsize;
507 }
508 
509 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
510 {
511         struct jffs2_sb_info *c;
512         struct inode *root_i;
513         int ret;
514         size_t blocks;
515 
516         c = JFFS2_SB_INFO(sb);
517 
518 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
519         if (c->mtd->type == MTD_NANDFLASH) {
520                 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
521                 return -EINVAL;
522         }
523         if (c->mtd->type == MTD_DATAFLASH) {
524                 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
525                 return -EINVAL;
526         }
527 #endif
528 
529         c->flash_size = c->mtd->size;
530         c->sector_size = c->mtd->erasesize;
531         blocks = c->flash_size / c->sector_size;
532 
533         /*
534          * Size alignment check
535          */
536         if ((c->sector_size * blocks) != c->flash_size) {
537                 c->flash_size = c->sector_size * blocks;
538                 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
539                         c->flash_size / 1024);
540         }
541 
542         if (c->flash_size < 5*c->sector_size) {
543                 pr_err("Too few erase blocks (%d)\n",
544                        c->flash_size / c->sector_size);
545                 return -EINVAL;
546         }
547 
548         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
549 
550         /* NAND (or other bizarre) flash... do setup accordingly */
551         ret = jffs2_flash_setup(c);
552         if (ret)
553                 return ret;
554 
555         c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
556         c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
557         if (!c->inocache_list) {
558                 ret = -ENOMEM;
559                 goto out_wbuf;
560         }
561 
562         jffs2_init_xattr_subsystem(c);
563 
564         if ((ret = jffs2_do_mount_fs(c)))
565                 goto out_inohash;
566 
567         jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
568         root_i = jffs2_iget(sb, 1);
569         if (IS_ERR(root_i)) {
570                 jffs2_dbg(1, "get root inode failed\n");
571                 ret = PTR_ERR(root_i);
572                 goto out_root;
573         }
574 
575         ret = -ENOMEM;
576 
577         jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
578         sb->s_root = d_make_root(root_i);
579         if (!sb->s_root)
580                 goto out_root;
581 
582         sb->s_maxbytes = 0xFFFFFFFF;
583         sb->s_blocksize = PAGE_CACHE_SIZE;
584         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
585         sb->s_magic = JFFS2_SUPER_MAGIC;
586         if (!(sb->s_flags & MS_RDONLY))
587                 jffs2_start_garbage_collect_thread(c);
588         return 0;
589 
590 out_root:
591         jffs2_free_ino_caches(c);
592         jffs2_free_raw_node_refs(c);
593         if (jffs2_blocks_use_vmalloc(c))
594                 vfree(c->blocks);
595         else
596                 kfree(c->blocks);
597  out_inohash:
598         jffs2_clear_xattr_subsystem(c);
599         kfree(c->inocache_list);
600  out_wbuf:
601         jffs2_flash_cleanup(c);
602 
603         return ret;
604 }
605 
606 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
607                                    struct jffs2_inode_info *f)
608 {
609         iput(OFNI_EDONI_2SFFJ(f));
610 }
611 
612 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
613                                               int inum, int unlinked)
614 {
615         struct inode *inode;
616         struct jffs2_inode_cache *ic;
617 
618         if (unlinked) {
619                 /* The inode has zero nlink but its nodes weren't yet marked
620                    obsolete. This has to be because we're still waiting for
621                    the final (close() and) iput() to happen.
622 
623                    There's a possibility that the final iput() could have
624                    happened while we were contemplating. In order to ensure
625                    that we don't cause a new read_inode() (which would fail)
626                    for the inode in question, we use ilookup() in this case
627                    instead of iget().
628 
629                    The nlink can't _become_ zero at this point because we're
630                    holding the alloc_sem, and jffs2_do_unlink() would also
631                    need that while decrementing nlink on any inode.
632                 */
633                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
634                 if (!inode) {
635                         jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
636                                   inum);
637 
638                         spin_lock(&c->inocache_lock);
639                         ic = jffs2_get_ino_cache(c, inum);
640                         if (!ic) {
641                                 jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
642                                           inum);
643                                 spin_unlock(&c->inocache_lock);
644                                 return NULL;
645                         }
646                         if (ic->state != INO_STATE_CHECKEDABSENT) {
647                                 /* Wait for progress. Don't just loop */
648                                 jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
649                                           ic->ino, ic->state);
650                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
651                         } else {
652                                 spin_unlock(&c->inocache_lock);
653                         }
654 
655                         return NULL;
656                 }
657         } else {
658                 /* Inode has links to it still; they're not going away because
659                    jffs2_do_unlink() would need the alloc_sem and we have it.
660                    Just iget() it, and if read_inode() is necessary that's OK.
661                 */
662                 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
663                 if (IS_ERR(inode))
664                         return ERR_CAST(inode);
665         }
666         if (is_bad_inode(inode)) {
667                 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
668                           inum, unlinked);
669                 /* NB. This will happen again. We need to do something appropriate here. */
670                 iput(inode);
671                 return ERR_PTR(-EIO);
672         }
673 
674         return JFFS2_INODE_INFO(inode);
675 }
676 
677 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
678                                    struct jffs2_inode_info *f,
679                                    unsigned long offset,
680                                    unsigned long *priv)
681 {
682         struct inode *inode = OFNI_EDONI_2SFFJ(f);
683         struct page *pg;
684 
685         pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
686                              (void *)jffs2_do_readpage_unlock, inode);
687         if (IS_ERR(pg))
688                 return (void *)pg;
689 
690         *priv = (unsigned long)pg;
691         return kmap(pg);
692 }
693 
694 void jffs2_gc_release_page(struct jffs2_sb_info *c,
695                            unsigned char *ptr,
696                            unsigned long *priv)
697 {
698         struct page *pg = (void *)*priv;
699 
700         kunmap(pg);
701         page_cache_release(pg);
702 }
703 
704 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
705         int ret = 0;
706 
707         if (jffs2_cleanmarker_oob(c)) {
708                 /* NAND flash... do setup accordingly */
709                 ret = jffs2_nand_flash_setup(c);
710                 if (ret)
711                         return ret;
712         }
713 
714         /* and Dataflash */
715         if (jffs2_dataflash(c)) {
716                 ret = jffs2_dataflash_setup(c);
717                 if (ret)
718                         return ret;
719         }
720 
721         /* and Intel "Sibley" flash */
722         if (jffs2_nor_wbuf_flash(c)) {
723                 ret = jffs2_nor_wbuf_flash_setup(c);
724                 if (ret)
725                         return ret;
726         }
727 
728         /* and an UBI volume */
729         if (jffs2_ubivol(c)) {
730                 ret = jffs2_ubivol_setup(c);
731                 if (ret)
732                         return ret;
733         }
734 
735         return ret;
736 }
737 
738 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
739 
740         if (jffs2_cleanmarker_oob(c)) {
741                 jffs2_nand_flash_cleanup(c);
742         }
743 
744         /* and DataFlash */
745         if (jffs2_dataflash(c)) {
746                 jffs2_dataflash_cleanup(c);
747         }
748 
749         /* and Intel "Sibley" flash */
750         if (jffs2_nor_wbuf_flash(c)) {
751                 jffs2_nor_wbuf_flash_cleanup(c);
752         }
753 
754         /* and an UBI volume */
755         if (jffs2_ubivol(c)) {
756                 jffs2_ubivol_cleanup(c);
757         }
758 }
759 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp