Searched refs:dirty (Results 1 - 19 of 19) sorted by relevance

/u-boot/fs/ubifs/
H A Dlprops.c16 * an empty LEB for the journal, or a very dirty LEB for garbage collection.
37 return lprops->free + lprops->dirty;
39 return lprops->dirty;
52 * is either the amount of free space or the amount of dirty space, depending
90 * of free space or the amount of dirty space, depending on the category.
414 if (lprops->free + lprops->dirty == c->leb_size) {
422 if (lprops->dirty + lprops->free >= c->min_idx_node_sz)
425 if (lprops->dirty >= c->dead_wm &&
426 lprops->dirty > lprops->free)
465 * @spc: amount of free and dirty spac
527 ubifs_change_lp(struct ubifs_info *c, const struct ubifs_lprops *lp, int free, int dirty, int flags, int idx_gc_cnt) argument
656 ubifs_change_one_lp(struct ubifs_info *c, int lnum, int free, int dirty, int flags_set, int flags_clean, int idx_gc_cnt) argument
695 ubifs_update_one_lp(struct ubifs_info *c, int lnum, int free, int dirty, int flags_set, int flags_clean) argument
1028 int cat, lnum = lp->lnum, is_idx = 0, used = 0, free, dirty, ret; local
[all...]
H A Dreplay.c73 * @dirty: dirty bytes in the bud
80 int dirty; member in struct:bud_entry
84 * set_bud_lprops - set free and dirty space used by a bud.
95 int err = 0, dirty; local
105 dirty = lp->dirty;
106 if (b->bud->start == 0 && (lp->free != c->leb_size || lp->dirty != 0)) {
111 * @lp->dirty == 0, but that is not the case. The reason is that
114 * resets the free and dirty spac
[all...]
H A Dlpt.c26 * eraseblocks reusable. In the case of the big model, dirty eraseblocks are
28 * that LEB as dirty, and then only the dirty nodes are written out. Also, in
360 pack_bits(&addr, &pos, pnode->lprops[i].dirty >> 3,
422 pack_bits(&addr, &pos, ltab[i].dirty, c->lpt_spc_bits);
454 * ubifs_add_lpt_dirt - add dirty space to LPT LEB properties.
456 * @lnum: LEB number to which to add dirty space
457 * @dirty: amount of dirty space to add
459 void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty) argument
476 set_ltab(struct ubifs_info *c, int lnum, int free, int dirty) argument
1041 int dirty = ubifs_unpack_bits(&addr, &pos, c->lpt_spc_bits); local
1150 int dirty = pnode->lprops[i].dirty; local
[all...]
H A Dmisc.h19 * ubifs_zn_dirty - check if znode is dirty.
22 * This helper function returns %1 if @znode is dirty and %0 otherwise.
158 * ubifs_add_dirt - add dirty space to LEB properties.
160 * @lnum: LEB to add dirty space for
161 * @dirty: dirty space to add
163 * This is a helper function which increased amount of dirty LEB space. Returns
166 static inline int ubifs_add_dirt(struct ubifs_info *c, int lnum, int dirty) argument
168 return ubifs_update_one_lp(c, lnum, LPROPS_NC, dirty, 0, 0);
H A Dlpt_commit.c36 * first_dirty_cnode - find first dirty cnode.
40 * This function returns the first dirty cnode or %NULL if there is not one.
67 * next_dirty_cnode - find next dirty cnode.
70 * This function returns the next dirty cnode or %NULL if there is not one.
94 * get_cnodes_to_commit - create list of dirty cnodes to commit.
138 * @dirty: amount of dirty space to add
140 static void upd_ltab(struct ubifs_info *c, int lnum, int free, int dirty) argument
142 dbg_lp("LEB %d free %d dirty %d to %d +%d",
144 c->ltab[lnum - c->lpt_first].dirty, fre
1199 int i, lnum = -1, dirty = 0; local
1639 int err, len = c->leb_size, dirty = 0, node_type, node_num, node_len; local
[all...]
H A Dgc.c15 * contains a lot of dirty space (obsolete nodes), and copies the non-obsolete
18 * dirty in the TNC, and after the next commit, the garbage-collected LEB is
19 * to be reused. Garbage collection will cause the number of dirty index nodes
24 * LEBs which have less than @c->dead_wm bytes of free + dirty space are full
29 * actually reclaim even very small pieces of dirty space by garbage collecting
30 * enough dirty LEBs, but we do not bother doing this at this implementation.
37 * maximum size. So dark watermark is the amount of free + dirty space in LEB
39 * be unable to reclaim it. So, LEBs with free + dirty greater than dark
473 if (lp->free + lp->dirty == c->leb_size) {
518 dbg_gc("indexing LEB %d (free %d, dirty
[all...]
H A Dubifs.h780 * DIRTY_ZNODE: znode is dirty
834 * DIRTY_CNODE: cnode is dirty
848 * LTAB_DIRTY: ltab node is dirty
849 * LSAVE_DIRTY: lsave node is dirty
950 * @dirty: non-zero if the inode is dirty
954 * serializes "clean <-> dirty" state changes, serializes bulk-read,
955 * protects @dirty, @bulk_read, @ui_size, and @xattr_size
975 * operation is going to mark an inode dirty, it has to allocate budget for
976 * this. It cannot just mark it dirty becaus
1004 unsigned int dirty:1; member in struct:ubifs_inode
1075 int dirty; member in struct:ubifs_lprops
1093 int dirty; member in struct:ubifs_lpt_lprops
[all...]
H A Ddebug.c266 pr_err("\tdirty %u\n", ui->dirty);
670 spc = lp->free + lp->dirty;
677 pr_err("LEB %-7d free %-8d dirty %-8d used %-8d free + dirty %-8d flags %#x (",
678 lp->lnum, lp->free, lp->dirty, c->leb_size - spc, spc,
681 pr_err("LEB %-7d free %-8d dirty %-8d used %-8d free + dirty %-8d dark %-4d dead %-4d nodes fit %-3d flags %#-4x (",
682 lp->lnum, lp->free, lp->dirty, c->leb_size - spc, spc,
696 s = "dirty index";
710 s = "dirty";
[all...]
H A Dsuper.c496 if (!ui->dirty) {
516 ui->dirty = 0;
558 if (ui->dirty)
575 if (!ui->dirty) {
576 ui->dirty = 1;
955 * as "taken" in lprops. We also have to set free space to LEB size and dirty
1503 * Set the "dirty" flag so that if we reboot uncleanly we
1998 * of the media. For example, there will be dirty inodes if we failed
H A Drecovery.c339 * dirty.
759 * find a dirty LEB which could be GC'd into LEB Y! Even LEB X
1187 dbg_rcvry("could not find a dirty LEB");
1192 ubifs_assert(lp.free + lp.dirty >= wbuf->offs);
/u-boot/scripts/
H A Dsetlocalversion86 printf '%s' -dirty
110 *+|*+\ *) printf '%s' -dirty ;;
/u-boot/drivers/misc/
H A Dls2_sfp.c57 * @dirty: Whether the mirror registers have been written to (overridden)
66 bool programmed, dirty; member in struct:ls2_sfp_priv
132 priv->dirty = true;
169 if (!priv->dirty) {
170 dev_dbg(dev, "ignoring read request, since fuses are not dirty\n");
181 priv->dirty = false;
/u-boot/tools/dtoc/
H A Dfdt.py123 self.dirty = offset is None
216 The device tree is marked dirty so that the value will be written to
225 self.dirty = True
235 self.dirty = True
250 if self.dirty:
267 self.dirty = False
276 self.dirty = True
421 The device tree is marked dirty so that the value will be written to
453 The device tree is marked dirty so that the value will be written to
465 The device tree is marked dirty s
[all...]
/u-boot/fs/yaffs2/
H A Dyaffs_guts.c1342 obj->dirty = 1;
1377 if (cache->object == obj && cache->dirty)
1398 /* Find the lowest dirty chunk for this object */
1401 dev->cache[i].dirty) {
1417 cache->dirty = 0;
1439 /* Find a dirty object in the cache and flush it...
1440 * until there are no further dirty objects.
1445 if (dev->cache[i].object && dev->cache[i].dirty)
1456 * Then look for the least recently used non-dirty one.
1457 * Then look for the least recently used dirty on
[all...]
H A Dyaffs_guts.h133 int dirty; member in struct:yaffs_cache
134 int n_bytes; /* Only valid if the cache is dirty */
379 struct list_head dirty; /* Entry for list of dirty directories */ member in struct:yaffs_dir_var
405 u8 dirty:1; /* the object needs to be written to flash */ member in struct:yaffs_obj
586 /* Callback to mark the superblock dirty */
753 struct list_head dirty_dirs; /* List of dirty directories */
H A Dyaffs_yaffs1.c281 in->dirty = 0;
369 /* Now let's see if it was dirty */
H A Dyaffsfs.c1727 obj->dirty = 1;
2201 obj->dirty = 1;
2224 obj->dirty = 1;
H A Dyaffs_yaffs2.c41 * Calculate the oldest dirty sequence number if we don't know it.
53 /* Find the oldest dirty sequence number. */
103 * Update the oldest dirty sequence number whenever we dirty a block.
1246 in->dirty = 0;
1497 /* Now let's see if it was dirty */
/u-boot/tools/env/
H A Dfw_env.c115 int dirty; member in struct:environment
513 if (!environment.dirty)
602 environment.dirty = 1;
1454 environment.dirty = 1;
1516 environment.dirty = 1;
1527 environment.dirty = 1;

Completed in 136 milliseconds