Do spisu treści systemu plików

Skomentowany kod funkcji systemowych dotyczących realizacji operacji odczytu i zapisu w systemie plików FAT

Na tej stronie znajduje się skomentowany kod następujących funkcji:

fat_file_read()

fat_file_write()

fat_prefetch()

fat_truncate()

fat_bread()

fat_getblk()

fat_brelse()

fat_mark_buffer_dirty()

fat_set_uptodate()

fat_is_uptodate()

fat_ll_rw_block()

fat_prefetch()

static void fat_prefetch (struct inode *inode, struct fat_pre *pre, int nb)
{

	struct super_block *sb = inode->i_sb;

	struct buffer_head *bhreq[MSDOS_PREFETCH];
	int nbreq = 0;
	int i;
	for (i=0; i < nb; i++)
	{

		int sector = fat_smap(inode,pre->file_sector);
		if (sector != 0){

			struct buffer_head *bh;
			pre->file_sector++;
			bh = fat_getblk(sb, sector);
			if (bh == NULL)	break;
			pre->bhlist[pre->nblist++] = bh;
			if (!fat_is_uptodate(sb,bh))
				bhreq[nbreq++] = bh;
		}else{

			break;
		}
	}

 

	if (nbreq > 0) fat_ll_rw_block (sb,READ,nbreq,bhreq);

	for (i=pre->nblist; ibhlist[i] = NULL;
}

fat_file_read()

int fat_file_read(struct inode *inode, struct file *filp, char *buf, int count)
{
	struct super_block *sb = inode->i_sb;
	char *start = buf;
	char *end   = buf + count;
	int i;
	int left_in_file;
	struct fat_pre pre;
		

	if (!inode) {
		printk("fat_file_read: inode = NULL\n");
		return -EINVAL;
	}

	if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
		printk("fat_file_read: mode = %07o\n",inode->i_mode);
		return -EINVAL;
	}

	if (filp->f_pos >= inode->i_size || count <= 0) return 0;

	{

		int count_max = (filp->f_pos & (SECTOR_SIZE-1)) + count;
		int to_reada;		
		pre.file_sector = filp->f_pos >> SECTOR_BITS;
		to_reada = count_max / SECTOR_SIZE;
		if (count_max & (SECTOR_SIZE-1)) to_reada++;

		if (filp->f_reada || !MSDOS_I(inode)->i_binary){

			int ahead = read_ahead[MAJOR(inode->i_dev)];
			if (ahead == 0) ahead = 8;
			to_reada += ahead;
		}

 
		if (to_reada > MSDOS_PREFETCH) to_reada = MSDOS_PREFETCH;

		pre.nblist = 0;
		fat_prefetch (inode,&pre,to_reada);
	}

	pre.nolist = 0;

	while ((left_in_file = inode->i_size - filp->f_pos) > 0
		&& buf < end){

		struct buffer_head *bh = pre.bhlist[pre.nolist];
		char *data;
		int size,offset;
		if (bh == NULL) break;

		pre.bhlist[pre.nolist] = NULL;
		pre.nolist++;

		if (pre.nolist == MSDOS_PREFETCH/2){
			memcpy (pre.bhlist,pre.bhlist+MSDOS_PREFETCH/2
				,(MSDOS_PREFETCH/2)*sizeof(pre.bhlist[0]));
			pre.nblist -= MSDOS_PREFETCH/2;
			fat_prefetch (inode,&pre,MSDOS_PREFETCH/2);
			pre.nolist = 0;
		}

		wait_on_buffer(bh);

 

		if (!fat_is_uptodate(sb,bh)){
			fat_brelse (sb, bh);
			break;
		}

		offset = filp->f_pos & (SECTOR_SIZE-1);
		data = bh->b_data + offset;
		size = MIN(SECTOR_SIZE-offset,left_in_file);

		if (MSDOS_I(inode)->i_binary) {
			size = MIN(size,end-buf);
			memcpy_tofs(buf,data,size);
			buf += size;
			filp->f_pos += size;
		}else{

			for (; size && buf < end; size--) {
				char ch = *data++;
				filp->f_pos++;
				if (ch == 26){
					filp->f_pos = inode->i_size;
					break;
				}else if (ch != '\r'){
					put_user(ch,buf++);
				}
			}
		}

		fat_brelse(sb, bh);
	}

	for (i=0; i < pre.nblist; i++)
		fat_brelse (sb, pre.bhlist[i]);

	if (start == buf)
		return -EIO;

	if (!IS_RDONLY(inode))
		inode->i_atime = CURRENT_TIME;

	filp->f_reada = 1;

	return buf-start;
}

fat_file_write()

int fat_file_write(
	struct inode *inode,
	struct file *filp,
	const char *buf,
	int count)
{
	struct super_block *sb = inode->i_sb;
	int sector,offset,size,left,written;
	int error,carry;
	const char *start;
	char *to,ch;
	struct buffer_head *bh;
	int binary_mode = MSDOS_I(inode)->i_binary;

	if (!inode) {
		printk("fat_file_write: inode = NULL\n");
		return -EINVAL;
	}
	if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
		printk("fat_file_write: mode = %07o\n",inode->i_mode);
		return -EINVAL;
	}

	if (IS_IMMUTABLE(inode))
		return -EPERM;

	if (filp->f_flags & O_APPEND)
		filp->f_pos = inode->i_size;

	if (count <= 0)
		return 0;

	error = carry = 0;
	for (start = buf; count || carry; count -= size) {

		while (!(sector = fat_smap(inode,filp->f_pos >> SECTOR_BITS)))
			if ((error = fat_add_cluster(inode)) < 0) break;
		if (error) {
			fat_truncate(inode);
			break;
		}

		offset = filp->f_pos & (SECTOR_SIZE-1);
		size = MIN(SECTOR_SIZE-offset,MAX(carry,count));

		if (binary_mode
			&& offset == 0
			&& (size == SECTOR_SIZE
				|| filp->f_pos + size >= inode->i_size)){
			if (!(bh = fat_getblk(sb,sector))){
				error = -EIO;
				break;
			}

		} else if (!(bh = fat_bread(sb,sector))) {
			error = -EIO;
			break;
		}

		if (binary_mode) {
			memcpy_fromfs(bh->b_data+offset,buf,written = size);
			buf += size;
		} else {

			written = left = SECTOR_SIZE-offset;
			to = (char *) bh->b_data+(filp->f_pos & (SECTOR_SIZE-1));
			if (carry) {
				*to++ = '\n';
				left--;
				carry = 0;
			}
			for (size = 0; size < count && left; size++) {
				if ((ch = get_user(buf++)) == '\n') {
					*to++ = '\r';
					left--;
				}
				if (!left) carry = 1;
				else {
					*to++ = ch;
					left--;
				}
			}
			written -= left;
		}

		update_vm_cache(inode, filp->f_pos, bh->b_data + (filp->f_pos & (SECTOR_SIZE-1)), written);

		filp->f_pos += written;
		if (filp->f_pos > inode->i_size) {
			inode->i_size = filp->f_pos;
			inode->i_dirt = 1;
		}

 

		fat_set_uptodate(sb, bh, 1);
		fat_mark_buffer_dirty(sb, bh, 0);
		fat_brelse(sb, bh);
	}

	if (start == buf)
		return error;

	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
	inode->i_dirt = 1;
	return buf-start;
}

fat_truncate()

void fat_truncate(struct inode *inode)
{
	int cluster;

	if (IS_IMMUTABLE(inode))
		return;

	cluster = SECTOR_SIZE*MSDOS_SB(inode->i_sb)->cluster_size;
	(void) fat_free(inode,(inode->i_size+(cluster-1))/cluster);
	MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
	inode->i_dirt = 1;
}

fat_bread()

struct buffer_head *fat_bread (
	struct super_block *sb,
	int block)
{
	struct buffer_head *ret = NULL;

	if (sb->s_blocksize == 512) {
		ret = bread (sb->s_dev,block,512);
	} else {

		struct buffer_head *real = bread (sb->s_dev,block>>1,1024);

		if (real != NULL){

			ret = (struct buffer_head *)
			  kmalloc (sizeof(struct buffer_head), GFP_KERNEL);
			if (ret != NULL) {

				memset (ret,0,sizeof(*ret));
				ret->b_data = real->b_data;
				if (block & 1) ret->b_data += 512;

				ret->b_next = real;
			}else{
				brelse (real);
			}
		}
	}
	return ret;
}

fat_getblk()

struct buffer_head *fat_getblk (
	struct super_block *sb,
	int block)
{
	struct buffer_head *ret = NULL;

	if (sb->s_blocksize == 512){
		ret = getblk (sb->s_dev,block,512);
	}else{

		ret = fat_bread (sb,block);
	}
	return ret;
}

fat_brelse()

void fat_brelse (
	struct super_block *sb,
	struct buffer_head *bh)
{
	if (bh != NULL){

		if (sb->s_blocksize == 512){
			brelse (bh);
		}else{

			brelse (bh->b_next);
			kfree (bh);
		}
	}
}

fat_mark_buffer_dirty()

void fat_mark_buffer_dirty (
	struct super_block *sb,
	struct buffer_head *bh,
	int dirty_val)
{

	if (sb->s_blocksize != 512){
		bh = bh->b_next;
	}
	mark_buffer_dirty (bh,dirty_val);
}

fat_set_uptodate()

void fat_set_uptodate (
	struct super_block *sb,
	struct buffer_head *bh,
	int val)
{

	if (sb->s_blocksize != 512){
		bh = bh->b_next;
	}
	mark_buffer_uptodate(bh, val);
}

fat_is_uptodate()

int fat_is_uptodate (
	struct super_block *sb,
	struct buffer_head *bh)
{

	if (sb->s_blocksize != 512){
		bh = bh->b_next;
	}

	return buffer_uptodate(bh);
}

fat_ll_rw_block()

void fat_ll_rw_block (
	struct super_block *sb,
	int opr,
	int nbreq,
	struct buffer_head *bh[32])
{

	if (sb->s_blocksize == 512){
		ll_rw_block(opr,nbreq,bh);
	}else{

		struct buffer_head *tmp[32];
		int i;
		for (i=0; i < nbreq; i++){
			tmp[i] = bh[i]->b_next;
		}
		ll_rw_block(opr,nbreq,tmp);
	}
}