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

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

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

~ [ 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