自学教程：C++ ubifs_assert函数代码示例

int ubifs_leb_write_cb(struct ubifs_info *c, int lnum, const void *buf, int offs,		    int len, int dtype){	int err;	ubifs_assert(!c->ro_media && !c->ro_mount);	if (c->ro_error)		return -EROFS;	if (!dbg_is_tst_rcvry(c))		err = ubi_leb_write_cb(c->ubi, lnum, buf, offs, len, dtype);	else		err = dbg_leb_write_cb(c, lnum, buf, offs, len, dtype);	if (err) {		ubifs_err("writing %d bytes to LEB %d:%d failed, error %d",			  len, lnum, offs, err);		ubifs_ro_mode(c, err);		dbg_dump_stack();	}	return err;}

/** * ubifs_load_znode - load znode to TNC cache. * @c: UBIFS file-system description object * @zbr: znode branch * @parent: znode's parent * @iip: index in parent * * This function loads znode pointed to by @zbr into the TNC cache and * returns pointer to it in case of success and a negative error code in case * of failure. */struct ubifs_znode *ubifs_load_znode(struct ubifs_info *c,				     struct ubifs_zbranch *zbr,				     struct ubifs_znode *parent, int iip){	int err;	struct ubifs_znode *znode;	ubifs_assert(!zbr->znode);	/*	 * A slab cache is not presently used for znodes because the znode size	 * depends on the fanout which is stored in the superblock.	 */	znode = kzalloc(c->max_znode_sz, GFP_NOFS);	if (!znode)		return ERR_PTR(-ENOMEM);	err = read_znode(c, zbr->lnum, zbr->offs, zbr->len, znode);	if (err)		goto out;	atomic_long_inc(&c->clean_zn_cnt);	/*	 * Increment the global clean znode counter as well. It is OK that	 * global and per-FS clean znode counters may be inconsistent for some	 * short time (because we might be preempted at this point), the global	 * one is only used in shrinker.	 */	atomic_long_inc(&ubifs_clean_zn_cnt);	zbr->znode = znode;	znode->parent = parent;	znode->time = get_seconds();	znode->iip = iip;	return znode;out:	kfree(znode);	return ERR_PTR(err);}

/** * ubifs_wbuf_init - initialize write-buffer. * @c: UBIFS file-system description object * @wbuf: write-buffer to initialize * * This function initializes write-buffer. Returns zero in case of success * %-ENOMEM in case of failure. */int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf){	size_t size;	wbuf->buf = kmalloc(c->max_write_size, GFP_KERNEL);	if (!wbuf->buf)		return -ENOMEM;	size = (c->max_write_size / UBIFS_CH_SZ + 1) * sizeof(ino_t);	wbuf->inodes = kmalloc(size, GFP_KERNEL);	if (!wbuf->inodes) {		kfree(wbuf->buf);		wbuf->buf = NULL;		return -ENOMEM;	}	wbuf->used = 0;	wbuf->lnum = wbuf->offs = -1;	/*	 * If the LEB starts at the max. write size aligned address, then	 * write-buffer size has to be set to @c->max_write_size. Otherwise,	 * set it to something smaller so that it ends at the closest max.	 * write size boundary.	 */	size = c->max_write_size - (c->leb_start % c->max_write_size);	wbuf->avail = wbuf->size = size;	wbuf->dtype = UBI_UNKNOWN;	wbuf->sync_callback = NULL;	mutex_init(&wbuf->io_mutex);	spin_lock_init(&wbuf->lock);	wbuf->c = c;	wbuf->next_ino = 0;	hrtimer_init(&wbuf->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	wbuf->timer.function = wbuf_timer_callback_nolock;	wbuf->softlimit = ktime_set(WBUF_TIMEOUT_SOFTLIMIT, 0);	wbuf->delta = WBUF_TIMEOUT_HARDLIMIT - WBUF_TIMEOUT_SOFTLIMIT;	wbuf->delta *= 1000000000ULL;	ubifs_assert(wbuf->delta <= ULONG_MAX);	return 0;}

/** * ubifs_prepare_node - prepare node to be written to flash. * @c: UBIFS file-system description object * @node: the node to pad * @len: node length * @pad: if the buffer has to be padded * * This function prepares node at @node to be written to the media - it * calculates node CRC, fills the common header, and adds proper padding up to * the next minimum I/O unit if @pad is not zero. */void ubifs_prepare_node(struct ubifs_info *c, void *node, int len, int pad){	uint32_t crc;	struct ubifs_ch *ch = node;	unsigned long long sqnum = next_sqnum(c);	ubifs_assert(len >= UBIFS_CH_SZ);	ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);	ch->len = cpu_to_le32(len);	ch->group_type = UBIFS_NO_NODE_GROUP;	ch->sqnum = cpu_to_le64(sqnum);	ch->padding[0] = ch->padding[1] = 0;	crc = crc32(UBIFS_CRC32_INIT, node + 8, len - 8);	ch->crc = cpu_to_le32(crc);	if (pad) {		len = ALIGN(len, 8);		pad = ALIGN(len, c->min_io_size) - len;		ubifs_pad(c, node + len, pad);	}}

int ubifs_decrypt(const struct inode *inode, struct ubifs_data_node *dn,		  unsigned int *out_len, int block){	struct ubifs_info *c = inode->i_sb->s_fs_info;	int err;	unsigned int clen = le16_to_cpu(dn->compr_size);	unsigned int dlen = *out_len;	if (clen <= 0 || clen > UBIFS_BLOCK_SIZE || clen > dlen) {		ubifs_err(c, "bad compr_size: %i", clen);		return -EINVAL;	}	ubifs_assert(dlen <= UBIFS_BLOCK_SIZE);	err = fscrypt_decrypt_page(inode, virt_to_page(&dn->data), dlen,			offset_in_page(&dn->data), block);	if (err) {		ubifs_err(c, "fscrypt_decrypt_page failed: %i", err);		return err;	}	*out_len = clen;	return 0;}

//.........这里部分代码省略.........	struct ubifs_dent_node *dent;	struct inode *dir = file_inode(file);	struct ubifs_info *c = dir->i_sb->s_fs_info;	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);	if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)		/*		 * The directory was seek'ed to a senseless position or there		 * are no more entries.		 */		return 0;	if (file->f_version == 0) {		/*		 * The file was seek'ed, which means that @file->private_data		 * is now invalid. This may also be just the first		 * 'ubifs_readdir()' invocation, in which case		 * @file->private_data is NULL, and the below code is		 * basically a no-op.		 */		kfree(file->private_data);		file->private_data = NULL;	}	/*	 * 'generic_file_llseek()' unconditionally sets @file->f_version to	 * zero, and we use this for detecting whether the file was seek'ed.	 */	file->f_version = 1;	/* File positions 0 and 1 correspond to "." and ".." */	if (ctx->pos < 2) {		ubifs_assert(!file->private_data);		if (!dir_emit_dots(file, ctx))			return 0;		/* Find the first entry in TNC and save it */		lowest_dent_key(c, &key, dir->i_ino);		nm.name = NULL;		dent = ubifs_tnc_next_ent(c, &key, &nm);		if (IS_ERR(dent)) {			err = PTR_ERR(dent);			goto out;		}		ctx->pos = key_hash_flash(c, &dent->key);		file->private_data = dent;	}	dent = file->private_data;	if (!dent) {		/*		 * The directory was seek'ed to and is now readdir'ed.		 * Find the entry corresponding to @ctx->pos or the closest one.		 */		dent_key_init_hash(c, &key, dir->i_ino, ctx->pos);		nm.name = NULL;		dent = ubifs_tnc_next_ent(c, &key, &nm);		if (IS_ERR(dent)) {			err = PTR_ERR(dent);			goto out;		}		ctx->pos = key_hash_flash(c, &dent->key);		file->private_data = dent;	}

/** * ubifs_budget_space - ensure there is enough space to complete an operation. * @c: UBIFS file-system description object * @req: budget request * * This function allocates budget for an operation. It uses pessimistic * approximation of how much flash space the operation needs. The goal of this * function is to make sure UBIFS always has flash space to flush all dirty * pages, dirty inodes, and dirty znodes (liability). This function may force * commit, garbage-collection or write-back. Returns zero in case of success, * %-ENOSPC if there is no free space and other negative error codes in case of * failures. */int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req){	int err, idx_growth, data_growth, dd_growth, retried = 0;	ubifs_assert(req->new_page <= 1);	ubifs_assert(req->dirtied_page <= 1);	ubifs_assert(req->new_dent <= 1);	ubifs_assert(req->mod_dent <= 1);	ubifs_assert(req->new_ino <= 1);	ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);	ubifs_assert(req->dirtied_ino <= 4);	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);	ubifs_assert(!(req->new_ino_d & 7));	ubifs_assert(!(req->dirtied_ino_d & 7));	data_growth = calc_data_growth(c, req);	dd_growth = calc_dd_growth(c, req);	if (!data_growth && !dd_growth)		return 0;	idx_growth = calc_idx_growth(c, req);again:	spin_lock(&c->space_lock);	ubifs_assert(c->bi.idx_growth >= 0);	ubifs_assert(c->bi.data_growth >= 0);	ubifs_assert(c->bi.dd_growth >= 0);	if (unlikely(c->bi.nospace) && (c->bi.nospace_rp || !can_use_rp(c))) {		dbg_budg("no space");		spin_unlock(&c->space_lock);		return -ENOSPC;	}	c->bi.idx_growth += idx_growth;	c->bi.data_growth += data_growth;	c->bi.dd_growth += dd_growth;	err = do_budget_space(c);	if (likely(!err)) {		req->idx_growth = idx_growth;		req->data_growth = data_growth;		req->dd_growth = dd_growth;		spin_unlock(&c->space_lock);		return 0;	}	/* Restore the old values */	c->bi.idx_growth -= idx_growth;	c->bi.data_growth -= data_growth;	c->bi.dd_growth -= dd_growth;	spin_unlock(&c->space_lock);	if (req->fast) {		dbg_budg("no space for fast budgeting");		return err;	}	err = make_free_space(c);	cond_resched();	if (err == -EAGAIN) {		dbg_budg("try again");		goto again;	} else if (err == -ENOSPC) {		if (!retried) {			retried = 1;			dbg_budg("-ENOSPC, but anyway try once again");			goto again;		}		dbg_budg("FS is full, -ENOSPC");		c->bi.nospace = 1;		if (can_use_rp(c) || c->rp_size == 0)			c->bi.nospace_rp = 1;		smp_wmb();	} else		ubifs_err(c, "cannot budget space, error %d", err);	return err;}

/** * ubifs_release_budget - release budgeted free space. * @c: UBIFS file-system description object * @req: budget request * * This function releases the space budgeted by 'ubifs_budget_space()'. Note, * since the index changes (which were budgeted for in @req->idx_growth) will * only be written to the media on commit, this function moves the index budget * from @c->bi.idx_growth to @c->bi.uncommitted_idx. The latter will be zeroed * by the commit operation. */void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req){	ubifs_assert(req->new_page <= 1);	ubifs_assert(req->dirtied_page <= 1);	ubifs_assert(req->new_dent <= 1);	ubifs_assert(req->mod_dent <= 1);	ubifs_assert(req->new_ino <= 1);	ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);	ubifs_assert(req->dirtied_ino <= 4);	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);	ubifs_assert(!(req->new_ino_d & 7));	ubifs_assert(!(req->dirtied_ino_d & 7));	if (!req->recalculate) {		ubifs_assert(req->idx_growth >= 0);		ubifs_assert(req->data_growth >= 0);		ubifs_assert(req->dd_growth >= 0);	}	if (req->recalculate) {		req->data_growth = calc_data_growth(c, req);		req->dd_growth = calc_dd_growth(c, req);		req->idx_growth = calc_idx_growth(c, req);	}	if (!req->data_growth && !req->dd_growth)		return;	c->bi.nospace = c->bi.nospace_rp = 0;	smp_wmb();	spin_lock(&c->space_lock);	c->bi.idx_growth -= req->idx_growth;	c->bi.uncommitted_idx += req->idx_growth;	c->bi.data_growth -= req->data_growth;	c->bi.dd_growth -= req->dd_growth;	c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c);	ubifs_assert(c->bi.idx_growth >= 0);	ubifs_assert(c->bi.data_growth >= 0);	ubifs_assert(c->bi.dd_growth >= 0);	ubifs_assert(c->bi.min_idx_lebs < c->main_lebs);	ubifs_assert(!(c->bi.idx_growth & 7));	ubifs_assert(!(c->bi.data_growth & 7));	ubifs_assert(!(c->bi.dd_growth & 7));	spin_unlock(&c->space_lock);}

static int ubifs_finddir(struct super_block *sb, char *dirname,			 unsigned long root_inum, unsigned long *inum){	int err;	struct qstr nm;	union ubifs_key key;	struct ubifs_dent_node *dent;	struct ubifs_info *c;	struct file *file;	struct dentry *dentry;	struct inode *dir;	file = kzalloc(sizeof(struct file), 0);	dentry = kzalloc(sizeof(struct dentry), 0);	dir = kzalloc(sizeof(struct inode), 0);	if (!file || !dentry || !dir) {		printf("%s: Error, no memory for malloc!/n", __func__);		err = -ENOMEM;		goto out;	}	dir->i_sb = sb;	file->f_path.dentry = dentry;	file->f_path.dentry->d_parent = dentry;	file->f_path.dentry->d_inode = dir;	file->f_path.dentry->d_inode->i_ino = root_inum;	c = sb->s_fs_info;	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);	/* Find the first entry in TNC and save it */	lowest_dent_key(c, &key, dir->i_ino);	nm.name = NULL;	dent = ubifs_tnc_next_ent(c, &key, &nm);	if (IS_ERR(dent)) {		err = PTR_ERR(dent);		goto out;	}	file->f_pos = key_hash_flash(c, &dent->key);	file->private_data = dent;	while (1) {		dbg_gen("feed '%s', ino %llu, new f_pos %#x",			dent->name, (unsigned long long)le64_to_cpu(dent->inum),			key_hash_flash(c, &dent->key));		ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);		nm.len = le16_to_cpu(dent->nlen);		if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&		    (strlen(dirname) == nm.len)) {			*inum = le64_to_cpu(dent->inum);			return 1;		}		/* Switch to the next entry */		key_read(c, &dent->key, &key);		nm.name = (char *)dent->name;		dent = ubifs_tnc_next_ent(c, &key, &nm);		if (IS_ERR(dent)) {			err = PTR_ERR(dent);			goto out;		}		kfree(file->private_data);		file->f_pos = key_hash_flash(c, &dent->key);		file->private_data = dent;		cond_resched();	}out:	if (err != -ENOENT) {		ubifs_err("cannot find next direntry, error %d", err);		return err;	}	if (file)		free(file);	if (dentry)		free(dentry);	if (dir)		free(dir);	if (file->private_data)		kfree(file->private_data);	file->private_data = NULL;	file->f_pos = 2;	return 0;}

/** * ubifs_read_node_wbuf - read node from the media or write-buffer. * @wbuf: wbuf to check for un-written data * @buf: buffer to read to * @type: node type * @len: node length * @lnum: logical eraseblock number * @offs: offset within the logical eraseblock * * This function reads a node of known type and length, checks it and stores * in @buf. If the node partially or fully sits in the write-buffer, this * function takes data from the buffer, otherwise it reads the flash media. * Returns zero in case of success, %-EUCLEAN if CRC mismatched and a negative * error code in case of failure. */int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,			 int lnum, int offs){	const struct ubifs_info *c = wbuf->c;	int err, rlen, overlap;	struct ubifs_ch *ch = buf;#if defined(FEATURE_UBIFS_PERF_INDEX)	unsigned long long time1 = sched_clock();	int log_len = 0;#endif	dbg_io("LEB %d:%d, %s, length %d, jhead %s", lnum, offs,	       dbg_ntype(type), len, dbg_jhead(wbuf->jhead));	ubifs_assert(wbuf && lnum >= 0 && lnum < c->leb_cnt && offs >= 0);	ubifs_assert(!(offs & 7) && offs < c->leb_size);	ubifs_assert(type >= 0 && type < UBIFS_NODE_TYPES_CNT);	spin_lock(&wbuf->lock);	overlap = (lnum == wbuf->lnum && offs + len > wbuf->offs);	if (!overlap) {		/* We may safely unlock the write-buffer and read the data */		spin_unlock(&wbuf->lock);		return ubifs_read_node(c, buf, type, len, lnum, offs);	}	/* Don't read under wbuf */	rlen = wbuf->offs - offs;	if (rlen < 0)		rlen = 0;	/* Copy the rest from the write-buffer */	memcpy(buf + rlen, wbuf->buf + offs + rlen - wbuf->offs, len - rlen);	spin_unlock(&wbuf->lock);	if (rlen > 0) {		/* Read everything that goes before write-buffer */		err = ubifs_leb_read(c, lnum, buf, offs, rlen, 0);		if (err && err != -EBADMSG)			return err;	}	if (type != ch->node_type) {		ubifs_err("bad node type (%d but expected %d)",			  ch->node_type, type);		goto out;	}	err = ubifs_check_node(c, buf, lnum, offs, 0, 0);	if (err) {		ubifs_err("expected node type %d", type);		return err;	}	rlen = le32_to_cpu(ch->len);	if (rlen != len) {		ubifs_err("bad node length %d, expected %d", rlen, len);		goto out;	}#if defined(FEATURE_UBIFS_PERF_INDEX)	if(log_len > 0) {		ubifs_perf_lrcount(sched_clock() - time1, log_len);	}#endif	return 0;out:	ubifs_err("bad node at LEB %d:%d", lnum, offs);	dbg_dump_node(c, buf);	dbg_dump_stack();	return -EINVAL;}

/** * ubifs_wbuf_sync_nolock - synchronize write-buffer. * @wbuf: write-buffer to synchronize * * This function synchronizes write-buffer @buf and returns zero in case of * success or a negative error code in case of failure. * * Note, although write-buffers are of @c->max_write_size, this function does * not necessarily writes all @c->max_write_size bytes to the flash. Instead, * if the write-buffer is only partially filled with data, only the used part * of the write-buffer (aligned on @c->min_io_size boundary) is synchronized. * This way we waste less space. */int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf){	struct ubifs_info *c = wbuf->c;	int err, dirt, sync_len;	cancel_wbuf_timer_nolock(wbuf);	if (!wbuf->used || wbuf->lnum == -1)		/* Write-buffer is empty or not seeked */		return 0;	dbg_io("LEB %d:%d, %d bytes, jhead %s",	       wbuf->lnum, wbuf->offs, wbuf->used, dbg_jhead(wbuf->jhead));	ubifs_assert(!(wbuf->avail & 7));	ubifs_assert(wbuf->offs + wbuf->size <= c->leb_size);	ubifs_assert(wbuf->size >= c->min_io_size);	ubifs_assert(wbuf->size <= c->max_write_size);	ubifs_assert(wbuf->size % c->min_io_size == 0);	ubifs_assert(!c->ro_media && !c->ro_mount);	if (c->leb_size - wbuf->offs >= c->max_write_size)		ubifs_assert(!((wbuf->offs + wbuf->size) % c->max_write_size));	if (c->ro_error)		return -EROFS;	/*	 * Do not write whole write buffer but write only the minimum necessary	 * amount of min. I/O units.	 */	sync_len = ALIGN(wbuf->used, c->min_io_size);	dirt = sync_len - wbuf->used;	if (dirt)		ubifs_pad(c, wbuf->buf + wbuf->used, dirt);#if defined(FEATURE_UBIFS_PERF_INDEX)	if(wbuf->jhead == DATAHD)		err = ubifs_leb_write_log(c, wbuf->lnum, wbuf->buf, wbuf->offs, sync_len);	else#endif	err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs, sync_len);	if (err)		return err;	wbuf->w_count += sync_len; //MTK	spin_lock(&wbuf->lock);	wbuf->offs += sync_len;	/*	 * Now @wbuf->offs is not necessarily aligned to @c->max_write_size.	 * But our goal is to optimize writes and make sure we write in	 * @c->max_write_size chunks and to @c->max_write_size-aligned offset.	 * Thus, if @wbuf->offs is not aligned to @c->max_write_size now, make	 * sure that @wbuf->offs + @wbuf->size is aligned to	 * @c->max_write_size. This way we make sure that after next	 * write-buffer flush we are again at the optimal offset (aligned to	 * @c->max_write_size).	 */	if (c->leb_size - wbuf->offs < c->max_write_size)		wbuf->size = c->leb_size - wbuf->offs;	else if (wbuf->offs & (c->max_write_size - 1))		wbuf->size = ALIGN(wbuf->offs, c->max_write_size) - wbuf->offs;	else		wbuf->size = c->max_write_size;	wbuf->avail = wbuf->size;	wbuf->used = 0;	wbuf->next_ino = 0;	spin_unlock(&wbuf->lock);	if (wbuf->sync_callback)		err = wbuf->sync_callback(c, wbuf->lnum,					  c->leb_size - wbuf->offs, dirt);	return err;}

/** * ubifs_wbuf_write_nolock - write data to flash via write-buffer. * @wbuf: write-buffer * @buf: node to write * @len: node length * * This function writes data to flash via write-buffer @wbuf. This means that * the last piece of the node won't reach the flash media immediately if it * does not take whole max. write unit (@c->max_write_size). Instead, the node * will sit in RAM until the write-buffer is synchronized (e.g., by timer, or * because more data are appended to the write-buffer). * * This function returns zero in case of success and a negative error code in * case of failure. If the node cannot be written because there is no more * space in this logical eraseblock, %-ENOSPC is returned. */int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len){	struct ubifs_info *c = wbuf->c;	int err, written, n, aligned_len = ALIGN(len, 8);	dbg_io("%d bytes (%s) to jhead %s wbuf at LEB %d:%d", len,	       dbg_ntype(((struct ubifs_ch *)buf)->node_type),	       dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs + wbuf->used);	ubifs_assert(len > 0 && wbuf->lnum >= 0 && wbuf->lnum < c->leb_cnt);	ubifs_assert(wbuf->offs >= 0 && wbuf->offs % c->min_io_size == 0);	ubifs_assert(!(wbuf->offs & 7) && wbuf->offs <= c->leb_size);	ubifs_assert(wbuf->avail > 0 && wbuf->avail <= wbuf->size);	ubifs_assert(wbuf->size >= c->min_io_size);	ubifs_assert(wbuf->size <= c->max_write_size);	ubifs_assert(wbuf->size % c->min_io_size == 0);	ubifs_assert(mutex_is_locked(&wbuf->io_mutex));	ubifs_assert(!c->ro_media && !c->ro_mount);	ubifs_assert(!c->space_fixup);	if (c->leb_size - wbuf->offs >= c->max_write_size)		ubifs_assert(!((wbuf->offs + wbuf->size) % c->max_write_size));	if (c->leb_size - wbuf->offs - wbuf->used < aligned_len) {		err = -ENOSPC;		goto out;	}	cancel_wbuf_timer_nolock(wbuf);	if (c->ro_error)		return -EROFS;	if (aligned_len <= wbuf->avail) {		/*		 * The node is not very large and fits entirely within		 * write-buffer.		 */		memcpy(wbuf->buf + wbuf->used, buf, len);		if (aligned_len == wbuf->avail) {			dbg_io("flush jhead %s wbuf to LEB %d:%d",			       dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs);#if defined(FEATURE_UBIFS_PERF_INDEX)			if(wbuf->jhead == DATAHD)				err = ubifs_leb_write_log(c, wbuf->lnum, wbuf->buf, 						wbuf->offs, wbuf->size);			else#endif			err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf,					      wbuf->offs, wbuf->size);			if (err)				goto out;			wbuf->w_count += wbuf->size; //MTK			spin_lock(&wbuf->lock);			wbuf->offs += wbuf->size;			if (c->leb_size - wbuf->offs >= c->max_write_size)				wbuf->size = c->max_write_size;			else				wbuf->size = c->leb_size - wbuf->offs;			wbuf->avail = wbuf->size;			wbuf->used = 0;			wbuf->next_ino = 0;			spin_unlock(&wbuf->lock);		} else {			spin_lock(&wbuf->lock);			wbuf->avail -= aligned_len;			wbuf->used += aligned_len;			spin_unlock(&wbuf->lock);		}		goto exit;	}	written = 0;	if (wbuf->used) {		/*		 * The node is large enough and does not fit entirely within		 * current available space. We have to fill and flush		 * write-buffer and switch to the next max. write unit.		 */		dbg_io("flush jhead %s wbuf to LEB %d:%d",		       dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs);		memcpy(wbuf->buf + wbuf->used, buf, wbuf->avail);//.........这里部分代码省略.........

/** * ubifs_read_node_wbuf - read node from the media or write-buffer. * @wbuf: wbuf to check for un-written data * @buf: buffer to read to * @type: node type * @len: node length * @lnum: logical eraseblock number * @offs: offset within the logical eraseblock * * This function reads a node of known type and length, checks it and stores * in @buf. If the node partially or fully sits in the write-buffer, this * function takes data from the buffer, otherwise it reads the flash media. * Returns zero in case of success, %-EUCLEAN if CRC mismatched and a negative * error code in case of failure. */int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,			 int lnum, int offs){	const struct ubifs_info *c = wbuf->c;	int err, rlen, overlap;	struct ubifs_ch *ch = buf;	dbg_io("LEB %d:%d, %s, length %d", lnum, offs, dbg_ntype(type), len);	ubifs_assert(wbuf && lnum >= 0 && lnum < c->leb_cnt && offs >= 0);	ubifs_assert(!(offs & 7) && offs < c->leb_size);	ubifs_assert(type >= 0 && type < UBIFS_NODE_TYPES_CNT);	spin_lock(&wbuf->lock);	overlap = (lnum == wbuf->lnum && offs + len > wbuf->offs);	if (!overlap) {		/* We may safely unlock the write-buffer and read the data */		spin_unlock(&wbuf->lock);		return ubifs_read_node(c, buf, type, len, lnum, offs);	}	/* Don't read under wbuf */	rlen = wbuf->offs - offs;	if (rlen < 0)		rlen = 0;	/* Copy the rest from the write-buffer */	memcpy(buf + rlen, wbuf->buf + offs + rlen - wbuf->offs, len - rlen);	spin_unlock(&wbuf->lock);	if (rlen > 0) {		/* Read everything that goes before write-buffer */		err = ubi_read(c->ubi, lnum, buf, offs, rlen);		if (err && err != -EBADMSG) {			ubifs_err("failed to read node %d from LEB %d:%d, "				  "error %d", type, lnum, offs, err);			dbg_dump_stack();			return err;		}	}	if (type != ch->node_type) {		ubifs_err("bad node type (%d but expected %d)",			  ch->node_type, type);		goto out;	}	err = ubifs_check_node(c, buf, lnum, offs, 0, 0);	if (err) {		ubifs_err("expected node type %d", type);		return err;	}	rlen = le32_to_cpu(ch->len);	if (rlen != len) {		ubifs_err("bad node length %d, expected %d", rlen, len);		goto out;	}	return 0;out:	ubifs_err("bad node at LEB %d:%d", lnum, offs);	dbg_dump_node(c, buf);	dbg_dump_stack();	return -EINVAL;}

/** * ubifs_check_node - check node. * @c: UBIFS file-system description object * @buf: node to check * @lnum: logical eraseblock number * @offs: offset within the logical eraseblock * @quiet: print no messages * @must_chk_crc: indicates whether to always check the CRC * * This function checks node magic number and CRC checksum. This function also * validates node length to prevent UBIFS from becoming crazy when an attacker * feeds it a file-system image with incorrect nodes. For example, too large * node length in the common header could cause UBIFS to read memory outside of * allocated buffer when checking the CRC checksum. * * This function may skip data nodes CRC checking if @c->no_chk_data_crc is * true, which is controlled by corresponding UBIFS mount option. However, if * @must_chk_crc is true, then @c->no_chk_data_crc is ignored and CRC is * checked. Similarly, if @c->mounting or @c->remounting_rw is true (we are * mounting or re-mounting to R/W mode), @c->no_chk_data_crc is ignored and CRC * is checked. This is because during mounting or re-mounting from R/O mode to * R/W mode we may read journal nodes (when replying the journal or doing the * recovery) and the journal nodes may potentially be corrupted, so checking is * required. * * This function returns zero in case of success and %-EUCLEAN in case of bad * CRC or magic. */int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,		     int offs, int quiet, int must_chk_crc){	int err = -EINVAL, type, node_len;	uint32_t crc, node_crc, magic;	const struct ubifs_ch *ch = buf;	ubifs_assert(lnum >= 0 && lnum < c->leb_cnt && offs >= 0);	ubifs_assert(!(offs & 7) && offs < c->leb_size);	magic = le32_to_cpu(ch->magic);	if (magic != UBIFS_NODE_MAGIC) {		if (!quiet)			ubifs_err("bad magic %#08x, expected %#08x",				  magic, UBIFS_NODE_MAGIC);		err = -EUCLEAN;		goto out;	}	type = ch->node_type;	if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) {		if (!quiet)			ubifs_err("bad node type %d", type);		goto out;	}	node_len = le32_to_cpu(ch->len);	if (node_len + offs > c->leb_size)		goto out_len;	if (c->ranges[type].max_len == 0) {		if (node_len != c->ranges[type].len)			goto out_len;	} else if (node_len < c->ranges[type].min_len ||		   node_len > c->ranges[type].max_len)		goto out_len;	if (!must_chk_crc && type == UBIFS_DATA_NODE && !c->mounting &&	    !c->remounting_rw && c->no_chk_data_crc)		return 0;	crc = crc32(UBIFS_CRC32_INIT, buf + 8, node_len - 8);	node_crc = le32_to_cpu(ch->crc);	if (crc != node_crc) {		if (!quiet)			ubifs_err("bad CRC: calculated %#08x, read %#08x",				  crc, node_crc);		err = -EUCLEAN;		goto out;	}	return 0;out_len:	if (!quiet)		ubifs_err("bad node length %d", node_len);out:	if (!quiet) {		ubifs_err("bad node at LEB %d:%d", lnum, offs);		dbg_dump_node(c, buf);		dbg_dump_stack();	}	return err;}

static int ubifs_fill_super(struct super_block *sb, void *data, int silent){	struct ubi_volume_desc *ubi = sb->s_fs_info;	struct ubifs_info *c;	struct inode *root;	int err;	c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL);	if (!c)		return -ENOMEM;	spin_lock_init(&c->cnt_lock);	spin_lock_init(&c->cs_lock);	spin_lock_init(&c->buds_lock);	spin_lock_init(&c->space_lock);	spin_lock_init(&c->orphan_lock);	init_rwsem(&c->commit_sem);	mutex_init(&c->lp_mutex);	mutex_init(&c->tnc_mutex);	mutex_init(&c->log_mutex);	mutex_init(&c->mst_mutex);	mutex_init(&c->umount_mutex);	init_waitqueue_head(&c->cmt_wq);	c->buds = RB_ROOT;	c->old_idx = RB_ROOT;	c->size_tree = RB_ROOT;	c->orph_tree = RB_ROOT;	INIT_LIST_HEAD(&c->infos_list);	INIT_LIST_HEAD(&c->idx_gc);	INIT_LIST_HEAD(&c->replay_list);	INIT_LIST_HEAD(&c->replay_buds);	INIT_LIST_HEAD(&c->uncat_list);	INIT_LIST_HEAD(&c->empty_list);	INIT_LIST_HEAD(&c->freeable_list);	INIT_LIST_HEAD(&c->frdi_idx_list);	INIT_LIST_HEAD(&c->unclean_leb_list);	INIT_LIST_HEAD(&c->old_buds);	INIT_LIST_HEAD(&c->orph_list);	INIT_LIST_HEAD(&c->orph_new);	c->highest_inum = UBIFS_FIRST_INO;	c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM;	ubi_get_volume_info(ubi, &c->vi);	ubi_get_device_info(c->vi.ubi_num, &c->di);	/* Re-open the UBI device in read-write mode */	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);	if (IS_ERR(c->ubi)) {		err = PTR_ERR(c->ubi);		goto out_free;	}	c->vfs_sb = sb;	sb->s_fs_info = c;	sb->s_magic = UBIFS_SUPER_MAGIC;	sb->s_blocksize = UBIFS_BLOCK_SIZE;	sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT;	sb->s_dev = c->vi.cdev;	sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c);	if (c->max_inode_sz > MAX_LFS_FILESIZE)		sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE;	if (c->rw_incompat) {		ubifs_err("the file-system is not R/W-compatible");		ubifs_msg("on-flash format version is w%d/r%d, but software "			  "only supports up to version w%d/r%d", c->fmt_version,			  c->ro_compat_version, UBIFS_FORMAT_VERSION,			  UBIFS_RO_COMPAT_VERSION);		return -EROFS;	}	mutex_lock(&c->umount_mutex);	err = mount_ubifs(c);	if (err) {		ubifs_assert(err < 0);		goto out_unlock;	}	/* Read the root inode */	root = ubifs_iget(sb, UBIFS_ROOT_INO);	if (IS_ERR(root)) {		err = PTR_ERR(root);		goto out_umount;	}	sb->s_root = NULL;	mutex_unlock(&c->umount_mutex);	return 0;out_umount:	ubifs_umount(c);out_unlock:	mutex_unlock(&c->umount_mutex);	ubi_close_volume(c->ubi);out_free:	kfree(c);	return err;//.........这里部分代码省略.........

static int ubifs_link(struct dentry *old_dentry, struct inode *dir,		      struct dentry *dentry){	struct ubifs_info *c = dir->i_sb->s_fs_info;	struct inode *inode = d_inode(old_dentry);	struct ubifs_inode *ui = ubifs_inode(inode);	struct ubifs_inode *dir_ui = ubifs_inode(dir);	int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);	struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,				.dirtied_ino_d = ALIGN(ui->data_len, 8) };	/*	 * Budget request settings: new direntry, changing the target inode,	 * changing the parent inode.	 */	dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",		dentry, inode->i_ino,		inode->i_nlink, dir->i_ino);	ubifs_assert(mutex_is_locked(&dir->i_mutex));	ubifs_assert(mutex_is_locked(&inode->i_mutex));	err = dbg_check_synced_i_size(c, inode);	if (err)		return err;	err = ubifs_budget_space(c, &req);	if (err)		return err;	lock_2_inodes(dir, inode);	inc_nlink(inode);	ihold(inode);	inode->i_ctime = ubifs_current_time(inode);	dir->i_size += sz_change;	dir_ui->ui_size = dir->i_size;	dir->i_mtime = dir->i_ctime = inode->i_ctime;	err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);	if (err)		goto out_cancel;	unlock_2_inodes(dir, inode);	ubifs_release_budget(c, &req);	d_instantiate(dentry, inode);	return 0;out_cancel:	dir->i_size -= sz_change;	dir_ui->ui_size = dir->i_size;	drop_nlink(inode);	unlock_2_inodes(dir, inode);	ubifs_release_budget(c, &req);	iput(inode);	return err;}static int ubifs_unlink(struct inode *dir, struct dentry *dentry){	struct ubifs_info *c = dir->i_sb->s_fs_info;	struct inode *inode = d_inode(dentry);	struct ubifs_inode *dir_ui = ubifs_inode(dir);	int sz_change = CALC_DENT_SIZE(dentry->d_name.len);	int err, budgeted = 1;	struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };	unsigned int saved_nlink = inode->i_nlink;	/*	 * Budget request settings: deletion direntry, deletion inode (+1 for	 * @dirtied_ino), changing the parent directory inode. If budgeting	 * fails, go ahead anyway because we have extra space reserved for	 * deletions.	 */	dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",		dentry, inode->i_ino,		inode->i_nlink, dir->i_ino);	ubifs_assert(mutex_is_locked(&dir->i_mutex));	ubifs_assert(mutex_is_locked(&inode->i_mutex));	err = dbg_check_synced_i_size(c, inode);	if (err)		return err;	err = ubifs_budget_space(c, &req);	if (err) {		if (err != -ENOSPC)			return err;		budgeted = 0;	}	lock_2_inodes(dir, inode);	inode->i_ctime = ubifs_current_time(dir);	drop_nlink(inode);	dir->i_size -= sz_change;	dir_ui->ui_size = dir->i_size;	dir->i_mtime = dir->i_ctime = inode->i_ctime;	err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);	if (err)		goto out_cancel;	unlock_2_inodes(dir, inode);//.........这里部分代码省略.........

/** * ubifs_wbuf_write_nolock - write data to flash via write-buffer. * @wbuf: write-buffer * @buf: node to write * @len: node length * * This function writes data to flash via write-buffer @wbuf. This means that * the last piece of the node won't reach the flash media immediately if it * does not take whole minimal I/O unit. Instead, the node will sit in RAM * until the write-buffer is synchronized (e.g., by timer). * * This function returns zero in case of success and a negative error code in * case of failure. If the node cannot be written because there is no more * space in this logical eraseblock, %-ENOSPC is returned. */int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len){	struct ubifs_info *c = wbuf->c;	int err, written, n, aligned_len = ALIGN(len, 8), offs;	dbg_io("%d bytes (%s) to wbuf at LEB %d:%d", len,	       dbg_ntype(((struct ubifs_ch *)buf)->node_type), wbuf->lnum,	       wbuf->offs + wbuf->used);	ubifs_assert(len > 0 && wbuf->lnum >= 0 && wbuf->lnum < c->leb_cnt);	ubifs_assert(wbuf->offs >= 0 && wbuf->offs % c->min_io_size == 0);	ubifs_assert(!(wbuf->offs & 7) && wbuf->offs <= c->leb_size);	ubifs_assert(wbuf->avail > 0 && wbuf->avail <= c->min_io_size);	ubifs_assert(mutex_is_locked(&wbuf->io_mutex));	if (c->leb_size - wbuf->offs - wbuf->used < aligned_len) {		err = -ENOSPC;		goto out;	}	cancel_wbuf_timer_nolock(wbuf);	if (c->ro_media)		return -EROFS;	if (aligned_len <= wbuf->avail) {		/*		 * The node is not very large and fits entirely within		 * write-buffer.		 */		memcpy(wbuf->buf + wbuf->used, buf, len);		if (aligned_len == wbuf->avail) {			dbg_io("flush wbuf to LEB %d:%d", wbuf->lnum,				wbuf->offs);			err = ubi_leb_write(c->ubi, wbuf->lnum, wbuf->buf,					    wbuf->offs, c->min_io_size,					    wbuf->dtype);			if (err)				goto out;			spin_lock(&wbuf->lock);			wbuf->offs += c->min_io_size;			wbuf->avail = c->min_io_size;			wbuf->used = 0;			wbuf->next_ino = 0;			spin_unlock(&wbuf->lock);		} else {			spin_lock(&wbuf->lock);			wbuf->avail -= aligned_len;			wbuf->used += aligned_len;			spin_unlock(&wbuf->lock);		}		goto exit;	}	/*	 * The node is large enough and does not fit entirely within current	 * minimal I/O unit. We have to fill and flush write-buffer and switch	 * to the next min. I/O unit.	 */	dbg_io("flush wbuf to LEB %d:%d", wbuf->lnum, wbuf->offs);	memcpy(wbuf->buf + wbuf->used, buf, wbuf->avail);	err = ubi_leb_write(c->ubi, wbuf->lnum, wbuf->buf, wbuf->offs,			    c->min_io_size, wbuf->dtype);	if (err)		goto out;	offs = wbuf->offs + c->min_io_size;	len -= wbuf->avail;	aligned_len -= wbuf->avail;	written = wbuf->avail;	/*	 * The remaining data may take more whole min. I/O units, so write the	 * remains multiple to min. I/O unit size directly to the flash media.	 * We align node length to 8-byte boundary because we anyway flash wbuf	 * if the remaining space is less than 8 bytes.	 */	n = aligned_len >> c->min_io_shift;	if (n) {		n <<= c->min_io_shift;		dbg_io("write %d bytes to LEB %d:%d", n, wbuf->lnum, offs);		err = ubi_leb_write(c->ubi, wbuf->lnum, buf + written, offs, n,				    wbuf->dtype);//.........这里部分代码省略.........

/** * ubifs_budget_space - ensure there is enough space to complete an operation. * @c: UBIFS file-system description object * @req: budget request * * This function allocates budget for an operation. It uses pessimistic * approximation of how much flash space the operation needs. The goal of this * function is to make sure UBIFS always has flash space to flush all dirty * pages, dirty inodes, and dirty znodes (liability). This function may force * commit, garbage-collection or write-back. Returns zero in case of success, * %-ENOSPC if there is no free space and other negative error codes in case of * failures. */int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req){	int uninitialized_var(cmt_retries), uninitialized_var(wb_retries);	int err, idx_growth, data_growth, dd_growth;	struct retries_info ri;	ubifs_assert(req->dirtied_ino <= 4);	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);	data_growth = calc_data_growth(c, req);	dd_growth = calc_dd_growth(c, req);	if (!data_growth && !dd_growth)		return 0;	idx_growth = calc_idx_growth(c, req);	memset(&ri, 0, sizeof(struct retries_info));again:	spin_lock(&c->space_lock);	ubifs_assert(c->budg_idx_growth >= 0);	ubifs_assert(c->budg_data_growth >= 0);	ubifs_assert(c->budg_dd_growth >= 0);	if (unlikely(c->nospace) && (c->nospace_rp || !can_use_rp(c))) {		dbg_budg("no space");		spin_unlock(&c->space_lock);		return -ENOSPC;	}	c->budg_idx_growth += idx_growth;	c->budg_data_growth += data_growth;	c->budg_dd_growth += dd_growth;	err = do_budget_space(c);	if (likely(!err)) {		req->idx_growth = idx_growth;		req->data_growth = data_growth;		req->dd_growth = dd_growth;		spin_unlock(&c->space_lock);		return 0;	}	/* Restore the old values */	c->budg_idx_growth -= idx_growth;	c->budg_data_growth -= data_growth;	c->budg_dd_growth -= dd_growth;	spin_unlock(&c->space_lock);	if (req->fast) {		dbg_budg("no space for fast budgeting");		return err;	}	err = make_free_space(c, &ri);	if (err == -EAGAIN) {		dbg_budg("try again");		cond_resched();		goto again;	} else if (err == -ENOSPC) {		dbg_budg("FS is full, -ENOSPC");		c->nospace = 1;		if (can_use_rp(c) || c->rp_size == 0)			c->nospace_rp = 1;		smp_wmb();	} else		ubifs_err("cannot budget space, error %d", err);	return err;}

static int ubifs_printdir(struct file *file, void *dirent){	int err, over = 0;	struct qstr nm;	union ubifs_key key;	struct ubifs_dent_node *dent;	struct inode *dir = file->f_path.dentry->d_inode;	struct ubifs_info *c = dir->i_sb->s_fs_info;	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);	if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)		/*		 * The directory was seek'ed to a senseless position or there		 * are no more entries.		 */		return 0;	if (file->f_pos == 1) {		/* Find the first entry in TNC and save it */		lowest_dent_key(c, &key, dir->i_ino);		nm.name = NULL;		dent = ubifs_tnc_next_ent(c, &key, &nm);		if (IS_ERR(dent)) {			err = PTR_ERR(dent);			goto out;		}		file->f_pos = key_hash_flash(c, &dent->key);		file->private_data = dent;	}	dent = file->private_data;	if (!dent) {		/*		 * The directory was seek'ed to and is now readdir'ed.		 * Find the entry corresponding to @file->f_pos or the		 * closest one.		 */		dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);		nm.name = NULL;		dent = ubifs_tnc_next_ent(c, &key, &nm);		if (IS_ERR(dent)) {			err = PTR_ERR(dent);			goto out;		}		file->f_pos = key_hash_flash(c, &dent->key);		file->private_data = dent;	}	while (1) {		dbg_gen("feed '%s', ino %llu, new f_pos %#x",			dent->name, (unsigned long long)le64_to_cpu(dent->inum),			key_hash_flash(c, &dent->key));		ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);		nm.len = le16_to_cpu(dent->nlen);		over = filldir(c, (char *)dent->name, nm.len,			       le64_to_cpu(dent->inum), dent->type);		if (over)			return 0;		/* Switch to the next entry */		key_read(c, &dent->key, &key);		nm.name = (char *)dent->name;		dent = ubifs_tnc_next_ent(c, &key, &nm);		if (IS_ERR(dent)) {			err = PTR_ERR(dent);			goto out;		}		kfree(file->private_data);		file->f_pos = key_hash_flash(c, &dent->key);		file->private_data = dent;		cond_resched();	}out:	if (err != -ENOENT) {		ubifs_err("cannot find next direntry, error %d", err);		return err;	}	kfree(file->private_data);	file->private_data = NULL;	file->f_pos = 2;	return 0;}

/** * ubifs_add_bud_to_log - add a new bud to the log. * @c: UBIFS file-system description object * @jhead: journal head the bud belongs to * @lnum: LEB number of the bud * @offs: starting offset of the bud * * This function writes reference node for the new bud LEB @lnum it to the log, * and adds it to the buds tress. It also makes sure that log size does not * exceed the 'c->max_bud_bytes' limit. Returns zero in case of success, * %-EAGAIN if commit is required, and a negative error codes in case of * failure. */int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs){	int err;	struct ubifs_bud *bud;	struct ubifs_ref_node *ref;	bud = kmalloc(sizeof(struct ubifs_bud), GFP_NOFS);	if (!bud)		return -ENOMEM;	ref = kzalloc(c->ref_node_alsz, GFP_NOFS);	if (!ref) {		kfree(bud);		return -ENOMEM;	}	mutex_lock(&c->log_mutex);	ubifs_assert(!c->ro_media && !c->ro_mount);	if (c->ro_error) {		err = -EROFS;		goto out_unlock;	}	/* Make sure we have enough space in the log */	if (empty_log_bytes(c) - c->ref_node_alsz < c->min_log_bytes) {		dbg_log("not enough log space - %lld, required %d",			empty_log_bytes(c), c->min_log_bytes);		ubifs_commit_required(c);		err = -EAGAIN;		goto out_unlock;	}	/*	 * Make sure the amount of space in buds will not exceed the	 * 'c->max_bud_bytes' limit, because we want to guarantee mount time	 * limits.	 *	 * It is not necessary to hold @c->buds_lock when reading @c->bud_bytes	 * because we are holding @c->log_mutex. All @c->bud_bytes take place	 * when both @c->log_mutex and @c->bud_bytes are locked.	 */	if (c->bud_bytes + c->leb_size - offs > c->max_bud_bytes) {		dbg_log("bud bytes %lld (%lld max), require commit",			c->bud_bytes, c->max_bud_bytes);		ubifs_commit_required(c);		err = -EAGAIN;		goto out_unlock;	}	/*	 * If the journal is full enough - start background commit. Note, it is	 * OK to read 'c->cmt_state' without spinlock because integer reads	 * are atomic in the kernel.	 */	if (c->bud_bytes >= c->bg_bud_bytes &&	    c->cmt_state == COMMIT_RESTING) {		dbg_log("bud bytes %lld (%lld max), initiate BG commit",			c->bud_bytes, c->max_bud_bytes);		ubifs_request_bg_commit(c);	}	bud->lnum = lnum;	bud->start = offs;	bud->jhead = jhead;	ref->ch.node_type = UBIFS_REF_NODE;	ref->lnum = cpu_to_le32(bud->lnum);	ref->offs = cpu_to_le32(bud->start);	ref->jhead = cpu_to_le32(jhead);	if (c->lhead_offs > c->leb_size - c->ref_node_alsz) {		c->lhead_lnum = ubifs_next_log_lnum(c, c->lhead_lnum);		c->lhead_offs = 0;	}	if (c->lhead_offs == 0) {		/* Must ensure next log LEB has been unmapped */		err = ubifs_leb_unmap(c, c->lhead_lnum);		if (err)			goto out_unlock;	}	if (bud->start == 0) {		/*		 * Before writing the LEB reference which refers an empty LEB		 * to the log, we have to make sure it is mapped, because		 * otherwise we'd risk to refer an LEB with garbage in case of		 * an unclean reboot, because the target LEB might have been//.........这里部分代码省略.........

/** * ubifs_read_superblock - read superblock. * @c: UBIFS file-system description object * * This function finds, reads and checks the superblock. If an empty UBI volume * is being mounted, this function creates default superblock. Returns zero in * case of success, and a negative error code in case of failure. */int ubifs_read_superblock(struct ubifs_info *c){	int err, sup_flags;	struct ubifs_sb_node *sup;	if (c->empty) {		err = create_default_filesystem(c);		if (err)			return err;	}	sup = ubifs_read_sb_node(c);	if (IS_ERR(sup))		return PTR_ERR(sup);	c->fmt_version = le32_to_cpu(sup->fmt_version);	c->ro_compat_version = le32_to_cpu(sup->ro_compat_version);	/*	 * The software supports all previous versions but not future versions,	 * due to the unavailability of time-travelling equipment.	 */	if (c->fmt_version > UBIFS_FORMAT_VERSION) {		struct super_block *sb = c->vfs_sb;		int mounting_ro = sb->s_flags & MS_RDONLY;		ubifs_assert(!c->ro_media || mounting_ro);		if (!mounting_ro ||		    c->ro_compat_version > UBIFS_RO_COMPAT_VERSION) {			ubifs_err("on-flash format version is w%d/r%d, but "				  "software only supports up to version "				  "w%d/r%d", c->fmt_version,				  c->ro_compat_version, UBIFS_FORMAT_VERSION,				  UBIFS_RO_COMPAT_VERSION);			if (c->ro_compat_version <= UBIFS_RO_COMPAT_VERSION) {				ubifs_msg("only R/O mounting is possible");				err = -EROFS;			} else				err = -EINVAL;			goto out;		}		/*		 * The FS is mounted R/O, and the media format is		 * R/O-compatible with the UBIFS implementation, so we can		 * mount.		 */		c->rw_incompat = 1;	}	if (c->fmt_version < 3) {		ubifs_err("on-flash format version %d is not supported",			  c->fmt_version);		err = -EINVAL;		goto out;	}	switch (sup->key_hash) {	case UBIFS_KEY_HASH_R5:		c->key_hash = key_r5_hash;		c->key_hash_type = UBIFS_KEY_HASH_R5;		break;	case UBIFS_KEY_HASH_TEST:		c->key_hash = key_test_hash;		c->key_hash_type = UBIFS_KEY_HASH_TEST;		break;	};	c->key_fmt = sup->key_fmt;	switch (c->key_fmt) {	case UBIFS_SIMPLE_KEY_FMT:		c->key_len = UBIFS_SK_LEN;		break;	default:		ubifs_err("unsupported key format");		err = -EINVAL;		goto out;	}	c->leb_cnt       = le32_to_cpu(sup->leb_cnt);	c->max_leb_cnt   = le32_to_cpu(sup->max_leb_cnt);	c->max_bud_bytes = le64_to_cpu(sup->max_bud_bytes);	c->log_lebs      = le32_to_cpu(sup->log_lebs);	c->lpt_lebs      = le32_to_cpu(sup->lpt_lebs);	c->orph_lebs     = le32_to_cpu(sup->orph_lebs);	c->jhead_cnt     = le32_to_cpu(sup->jhead_cnt) + NONDATA_JHEADS_CNT;	c->fanout        = le32_to_cpu(sup->fanout);	c->lsave_cnt     = le32_to_cpu(sup->lsave_cnt);	c->rp_size       = le64_to_cpu(sup->rp_size);	c->rp_uid        = le32_to_cpu(sup->rp_uid);//.........这里部分代码省略.........

/** * do_commit - commit the journal. * @c: UBIFS file-system description object * * This function implements UBIFS commit. It has to be called with commit lock * locked. Returns zero in case of success and a negative error code in case of * failure. */static int do_commit(struct ubifs_info *c){	int err, new_ltail_lnum, old_ltail_lnum, i;	struct ubifs_zbranch zroot;	struct ubifs_lp_stats lst;	dbg_cmt("start");	ubifs_assert(!c->ro_media && !c->ro_mount);	if (c->ro_error) {		err = -EROFS;		goto out_up;	}	if (nothing_to_commit(c)) {		up_write(&c->commit_sem);		err = 0;		goto out_cancel;	}	/* Sync all write buffers (necessary for recovery) */	for (i = 0; i < c->jhead_cnt; i++) {		err = ubifs_wbuf_sync(&c->jheads[i].wbuf);		if (err)			goto out_up;	}	c->cmt_no += 1;	err = ubifs_gc_start_commit(c);	if (err)		goto out_up;	err = dbg_check_lprops(c);	if (err)		goto out_up;	err = ubifs_log_start_commit(c, &new_ltail_lnum);	if (err)		goto out_up;	err = ubifs_tnc_start_commit(c, &zroot);	if (err)		goto out_up;	err = ubifs_lpt_start_commit(c);	if (err)		goto out_up;	err = ubifs_orphan_start_commit(c);	if (err)		goto out_up;	ubifs_get_lp_stats(c, &lst);	up_write(&c->commit_sem);	err = ubifs_tnc_end_commit(c);	if (err)		goto out;	err = ubifs_lpt_end_commit(c);	if (err)		goto out;	err = ubifs_orphan_end_commit(c);	if (err)		goto out;	old_ltail_lnum = c->ltail_lnum;	err = ubifs_log_end_commit(c, new_ltail_lnum);	if (err)		goto out;	err = dbg_check_old_index(c, &zroot);	if (err)		goto out;	mutex_lock(&c->mst_mutex);	c->mst_node->cmt_no      = cpu_to_le64(c->cmt_no);	c->mst_node->log_lnum    = cpu_to_le32(new_ltail_lnum);	c->mst_node->root_lnum   = cpu_to_le32(zroot.lnum);	c->mst_node->root_offs   = cpu_to_le32(zroot.offs);	c->mst_node->root_len    = cpu_to_le32(zroot.len);	c->mst_node->ihead_lnum  = cpu_to_le32(c->ihead_lnum);	c->mst_node->ihead_offs  = cpu_to_le32(c->ihead_offs);	c->mst_node->index_size  = cpu_to_le64(c->bi.old_idx_sz);	c->mst_node->lpt_lnum    = cpu_to_le32(c->lpt_lnum);	c->mst_node->lpt_offs    = cpu_to_le32(c->lpt_offs);	c->mst_node->nhead_lnum  = cpu_to_le32(c->nhead_lnum);	c->mst_node->nhead_offs  = cpu_to_le32(c->nhead_offs);	c->mst_node->ltab_lnum   = cpu_to_le32(c->ltab_lnum);	c->mst_node->ltab_offs   = cpu_to_le32(c->ltab_offs);	c->mst_node->lsave_lnum  = cpu_to_le32(c->lsave_lnum);	c->mst_node->lsave_offs  = cpu_to_le32(c->lsave_offs);	c->mst_node->lscan_lnum  = cpu_to_le32(c->lscan_lnum);	c->mst_node->empty_lebs  = cpu_to_le32(lst.empty_lebs);	c->mst_node->idx_lebs    = cpu_to_le32(lst.idx_lebs);	c->mst_node->total_free  = cpu_to_le64(lst.total_free);	c->mst_node->total_dirty = cpu_to_le64(lst.total_dirty);	c->mst_node->total_used  = cpu_to_le64(lst.total_used);	c->mst_node->total_dead  = cpu_to_le64(lst.total_dead);//.........这里部分代码省略.........