开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
file.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

file.c：源码内容
  1. /*
  2.  * JFFS2 -- Journalling Flash File System, Version 2.
  3.  *
  4.  * Copyright (C) 2001 Red Hat, Inc.
  5.  *
  6.  * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
  7.  *
  8.  * The original JFFS, from which the design for JFFS2 was derived,
  9.  * was designed and implemented by Axis Communications AB.
  10.  *
  11.  * The contents of this file are subject to the Red Hat eCos Public
  12.  * License Version 1.1 (the "Licence"); you may not use this file
  13.  * except in compliance with the Licence.  You may obtain a copy of
  14.  * the Licence at http://www.redhat.com/
  15.  *
  16.  * Software distributed under the Licence is distributed on an "AS IS"
  17.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
  18.  * See the Licence for the specific language governing rights and
  19.  * limitations under the Licence.
  20.  *
  21.  * The Original Code is JFFS2 - Journalling Flash File System, version 2
  22.  *
  23.  * Alternatively, the contents of this file may be used under the
  24.  * terms of the GNU General Public License version 2 (the "GPL"), in
  25.  * which case the provisions of the GPL are applicable instead of the
  26.  * above.  If you wish to allow the use of your version of this file
  27.  * only under the terms of the GPL and not to allow others to use your
  28.  * version of this file under the RHEPL, indicate your decision by
  29.  * deleting the provisions above and replace them with the notice and
  30.  * other provisions required by the GPL.  If you do not delete the
  31.  * provisions above, a recipient may use your version of this file
  32.  * under either the RHEPL or the GPL.
  33.  *
  34.  * $Id: file.c,v 1.58.2.1 2002/02/23 14:25:36 dwmw2 Exp $
  35.  *
  36.  */
  38. #include <linux/kernel.h>
  39. #include <linux/mtd/compatmac.h> /* for min() */
  40. #include <linux/slab.h>
  41. #include <linux/fs.h>
  42. #include <linux/pagemap.h>
  43. #include <linux/jffs2.h>
  44. #include "nodelist.h"
  45. #include "crc32.h"
  47. extern int generic_file_open(struct inode *, struct file *) __attribute__((weak));
  48. extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin) __attribute__((weak));
  51. int jffs2_null_fsync(struct file *filp, struct dentry *dentry, int datasync)
  52. {
  53. /* Move along. Nothing to see here */
  54. return 0;
  55. }
  57. struct file_operations jffs2_file_operations =
  58. {
  59. llseek: generic_file_llseek,
  60. open: generic_file_open,
  61. read: generic_file_read,
  62. write: generic_file_write,
  63. ioctl: jffs2_ioctl,
  64. mmap: generic_file_mmap,
  65. fsync: jffs2_null_fsync
  66. };
  68. /* jffs2_file_inode_operations */
  70. struct inode_operations jffs2_file_inode_operations =
  71. {
  72. setattr: jffs2_setattr
  73. };
  75. struct address_space_operations jffs2_file_address_operations =
  76. {
  77. readpage: jffs2_readpage,
  78. prepare_write: jffs2_prepare_write,
  79. commit_write: jffs2_commit_write
  80. };
  82. int jffs2_setattr (struct dentry *dentry, struct iattr *iattr)
  83. {
  84. struct jffs2_full_dnode *old_metadata, *new_metadata;
  85. struct inode *inode = dentry->d_inode;
  86. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  87. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  88. struct jffs2_raw_inode *ri;
  89. unsigned short dev;
  90. unsigned char *mdata = NULL;
  91. int mdatalen = 0;
  92. unsigned int ivalid;
  93. __u32 phys_ofs, alloclen;
  94. int ret;
  95. D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lun", inode->i_ino));
  96. ret = inode_change_ok(inode, iattr);
  97. if (ret) 
  98. return ret;
  100. /* Special cases - we don't want more than one data node
  101.    for these types on the medium at any time. So setattr
  102.    must read the original data associated with the node
  103.    (i.e. the device numbers or the target name) and write
  104.    it out again with the appropriate data attached */
  105. if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  106. /* For these, we don't actually need to read the old node */
  107. dev =  (MAJOR(to_kdev_t(dentry->d_inode->i_rdev)) << 8) | 
  108. MINOR(to_kdev_t(dentry->d_inode->i_rdev));
  109. mdata = (char *)&dev;
  110. mdatalen = sizeof(dev);
  111. D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_tn", mdatalen));
  112. } else if (S_ISLNK(inode->i_mode)) {
  113. mdatalen = f->metadata->size;
  114. mdata = kmalloc(f->metadata->size, GFP_USER);
  115. if (!mdata)
  116. return -ENOMEM;
  117. ret = jffs2_read_dnode(c, f->metadata, mdata, 0, mdatalen);
  118. if (ret) {
  119. kfree(mdata);
  120. return ret;
  121. }
  122. D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink targetn", mdatalen));
  123. }
  125. ri = jffs2_alloc_raw_inode();
  126. if (!ri) {
  127. if (S_ISLNK(inode->i_mode))
  128. kfree(mdata);
  129. return -ENOMEM;
  130. }
  132. ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
  133. if (ret) {
  134. jffs2_free_raw_inode(ri);
  135. if (S_ISLNK(inode->i_mode))
  136.  kfree(mdata);
  137. return ret;
  138. }
  139. down(&f->sem);
  140.         ivalid = iattr->ia_valid;
  142. ri->magic = JFFS2_MAGIC_BITMASK;
  143. ri->nodetype = JFFS2_NODETYPE_INODE;
  144. ri->totlen = sizeof(*ri) + mdatalen;
  145. ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);
  147. ri->ino = inode->i_ino;
  148. ri->version = ++f->highest_version;
  150. ri->mode = (ivalid & ATTR_MODE)?iattr->ia_mode:inode->i_mode;
  151. ri->uid = (ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid;
  152. ri->gid = (ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid;
  154. if (ivalid & ATTR_MODE && ri->mode & S_ISGID &&
  155.     !in_group_p(ri->gid) && !capable(CAP_FSETID))
  156. ri->mode &= ~S_ISGID;
  158. ri->isize = (ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size;
  159. ri->atime = (ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime;
  160. ri->mtime = (ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime;
  161. ri->ctime = (ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime;
  163. ri->offset = 0;
  164. ri->csize = ri->dsize = mdatalen;
  165. ri->compr = JFFS2_COMPR_NONE;
  166. if (inode->i_size < ri->isize) {
  167. /* It's an extension. Make it a hole node */
  168. ri->compr = JFFS2_COMPR_ZERO;
  169. ri->dsize = ri->isize - inode->i_size;
  170. ri->offset = inode->i_size;
  171. }
  172. ri->node_crc = crc32(0, ri, sizeof(*ri)-8);
  173. if (mdatalen)
  174. ri->data_crc = crc32(0, mdata, mdatalen);
  175. else
  176. ri->data_crc = 0;
  178. new_metadata = jffs2_write_dnode(inode, ri, mdata, mdatalen, phys_ofs, NULL);
  179. if (S_ISLNK(inode->i_mode))
  180. kfree(mdata);
  182. jffs2_complete_reservation(c);
  184. if (IS_ERR(new_metadata)) {
  185. jffs2_free_raw_inode(ri);
  186. up(&f->sem);
  187. return PTR_ERR(new_metadata);
  188. }
  189. /* It worked. Update the inode */
  190. inode->i_atime = ri->atime;
  191. inode->i_ctime = ri->ctime;
  192. inode->i_mtime = ri->mtime;
  193. inode->i_mode = ri->mode;
  194. inode->i_uid = ri->uid;
  195. inode->i_gid = ri->gid;
  198. old_metadata = f->metadata;
  200. if (inode->i_size > ri->isize) {
  201. vmtruncate(inode, ri->isize);
  202. jffs2_truncate_fraglist (c, &f->fraglist, ri->isize);
  203. }
  205. if (inode->i_size < ri->isize) {
  206. jffs2_add_full_dnode_to_inode(c, f, new_metadata);
  207. inode->i_size = ri->isize;
  208. f->metadata = NULL;
  209. } else {
  210. f->metadata = new_metadata;
  211. }
  212. if (old_metadata) {
  213. jffs2_mark_node_obsolete(c, old_metadata->raw);
  214. jffs2_free_full_dnode(old_metadata);
  215. }
  216. jffs2_free_raw_inode(ri);
  217. up(&f->sem);
  218. return 0;
  219. }
  221. int jffs2_do_readpage_nolock (struct inode *inode, struct page *pg)
  222. {
  223. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  224. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  225. struct jffs2_node_frag *frag = f->fraglist;
  226. __u32 offset = pg->index << PAGE_CACHE_SHIFT;
  227. __u32 end = offset + PAGE_CACHE_SIZE;
  228. unsigned char *pg_buf;
  229. int ret;
  231. D1(printk(KERN_DEBUG "jffs2_do_readpage_nolock(): ino #%lu, page at offset 0x%xn", inode->i_ino, offset));
  233. if (!PageLocked(pg))
  234.                 PAGE_BUG(pg);
  236. while(frag && frag->ofs + frag->size  <= offset) {
  237. // D1(printk(KERN_DEBUG "skipping frag %d-%d; before the region we care aboutn", frag->ofs, frag->ofs + frag->size));
  238. frag = frag->next;
  239. }
  241. pg_buf = kmap(pg);
  243. /* XXX FIXME: Where a single physical node actually shows up in two
  244.    frags, we read it twice. Don't do that. */
  245. /* Now we're pointing at the first frag which overlaps our page */
  246. while(offset < end) {
  247. D2(printk(KERN_DEBUG "jffs2_readpage: offset %d, end %dn", offset, end));
  248. if (!frag || frag->ofs > offset) {
  249. __u32 holesize = end - offset;
  250. if (frag) {
  251. D1(printk(KERN_NOTICE "Eep. Hole in ino %ld fraglist. frag->ofs = 0x%08x, offset = 0x%08xn", inode->i_ino, frag->ofs, offset));
  252. holesize = min(holesize, frag->ofs - offset);
  253. D1(jffs2_print_frag_list(f));
  254. }
  255. D1(printk(KERN_DEBUG "Filling non-frag hole from %d-%dn", offset, offset+holesize));
  256. memset(pg_buf, 0, holesize);
  257. pg_buf += holesize;
  258. offset += holesize;
  259. continue;
  260. } else if (frag->ofs < offset && (offset & (PAGE_CACHE_SIZE-1)) != 0) {
  261. D1(printk(KERN_NOTICE "Eep. Overlap in ino #%ld fraglist. frag->ofs = 0x%08x, offset = 0x%08xn",
  262.   inode->i_ino, frag->ofs, offset));
  263. D1(jffs2_print_frag_list(f));
  264. memset(pg_buf, 0, end - offset);
  265. ClearPageUptodate(pg);
  266. SetPageError(pg);
  267. kunmap(pg);
  268. return -EIO;
  269. } else if (!frag->node) {
  270. __u32 holeend = min(end, frag->ofs + frag->size);
  271. D1(printk(KERN_DEBUG "Filling frag hole from %d-%d (frag 0x%x 0x%x)n", offset, holeend, frag->ofs, frag->ofs + frag->size));
  272. memset(pg_buf, 0, holeend - offset);
  273. pg_buf += holeend - offset;
  274. offset = holeend;
  275. frag = frag->next;
  276. continue;
  277. } else {
  278. __u32 readlen;
  279. readlen = min(frag->size, end - offset);
  280. D1(printk(KERN_DEBUG "Reading %d-%d from node at 0x%xn", frag->ofs, frag->ofs+readlen, frag->node->raw->flash_offset & ~3));
  281. ret = jffs2_read_dnode(c, frag->node, pg_buf, frag->ofs - frag->node->ofs, readlen);
  282. D2(printk(KERN_DEBUG "node read donen"));
  283. if (ret) {
  284. D1(printk(KERN_DEBUG"jffs2_readpage error %dn",ret));
  285. memset(pg_buf, 0, frag->size);
  286. ClearPageUptodate(pg);
  287. SetPageError(pg);
  288. kunmap(pg);
  289. return ret;
  290. }
  291. }
  292. pg_buf += frag->size;
  293. offset += frag->size;
  294. frag = frag->next;
  295. D2(printk(KERN_DEBUG "node read was OK. Loopingn"));
  296. }
  297. D2(printk(KERN_DEBUG "readpage finishingn"));
  298. SetPageUptodate(pg);
  299. ClearPageError(pg);
  301. flush_dcache_page(pg);
  303. kunmap(pg);
  304. D1(printk(KERN_DEBUG "readpage finishedn"));
  305. return 0;
  306. }
  308. int jffs2_do_readpage_unlock(struct inode *inode, struct page *pg)
  309. {
  310. int ret = jffs2_do_readpage_nolock(inode, pg);
  311. UnlockPage(pg);
  312. return ret;
  313. }
  316. int jffs2_readpage (struct file *filp, struct page *pg)
  317. {
  318. struct jffs2_inode_info *f = JFFS2_INODE_INFO(filp->f_dentry->d_inode);
  319. int ret;
  321. down(&f->sem);
  322. ret = jffs2_do_readpage_unlock(filp->f_dentry->d_inode, pg);
  323. up(&f->sem);
  324. return ret;
  325. }
  327. int jffs2_prepare_write (struct file *filp, struct page *pg, unsigned start, unsigned end)
  328. {
  329. struct inode *inode = filp->f_dentry->d_inode;
  330. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  331. __u32 pageofs = pg->index << PAGE_CACHE_SHIFT;
  332. int ret = 0;
  334. down(&f->sem);
  335. D1(printk(KERN_DEBUG "jffs2_prepare_write() nrpages %ldn", inode->i_mapping->nrpages));
  337. if (pageofs > inode->i_size) {
  338. /* Make new hole frag from old EOF to new page */
  339. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  340. struct jffs2_raw_inode ri;
  341. struct jffs2_full_dnode *fn;
  342. __u32 phys_ofs, alloc_len;
  344. D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EOF and new pagen",
  345.   (unsigned int)inode->i_size, pageofs));
  347. ret = jffs2_reserve_space(c, sizeof(ri), &phys_ofs, &alloc_len, ALLOC_NORMAL);
  348. if (ret) {
  349. up(&f->sem);
  350. return ret;
  351. }
  352. memset(&ri, 0, sizeof(ri));
  354. ri.magic = JFFS2_MAGIC_BITMASK;
  355. ri.nodetype = JFFS2_NODETYPE_INODE;
  356. ri.totlen = sizeof(ri);
  357. ri.hdr_crc = crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4);
  359. ri.ino = f->inocache->ino;
  360. ri.version = ++f->highest_version;
  361. ri.mode = inode->i_mode;
  362. ri.uid = inode->i_uid;
  363. ri.gid = inode->i_gid;
  364. ri.isize = max((__u32)inode->i_size, pageofs);
  365. ri.atime = ri.ctime = ri.mtime = CURRENT_TIME;
  366. ri.offset = inode->i_size;
  367. ri.dsize = pageofs - inode->i_size;
  368. ri.csize = 0;
  369. ri.compr = JFFS2_COMPR_ZERO;
  370. ri.node_crc = crc32(0, &ri, sizeof(ri)-8);
  371. ri.data_crc = 0;
  373. fn = jffs2_write_dnode(inode, &ri, NULL, 0, phys_ofs, NULL);
  374. jffs2_complete_reservation(c);
  375. if (IS_ERR(fn)) {
  376. ret = PTR_ERR(fn);
  377. up(&f->sem);
  378. return ret;
  379. }
  380. ret = jffs2_add_full_dnode_to_inode(c, f, fn);
  381. if (f->metadata) {
  382. jffs2_mark_node_obsolete(c, f->metadata->raw);
  383. jffs2_free_full_dnode(f->metadata);
  384. f->metadata = NULL;
  385. }
  386. if (ret) {
  387. D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in prepare_write, returned %dn", ret));
  388. jffs2_mark_node_obsolete(c, fn->raw);
  389. jffs2_free_full_dnode(fn);
  390. up(&f->sem);
  391. return ret;
  392. }
  393. inode->i_size = pageofs;
  394. }
  397. /* Read in the page if it wasn't already present */
  398. if (!Page_Uptodate(pg) && (start || end < PAGE_SIZE))
  399. ret = jffs2_do_readpage_nolock(inode, pg);
  400. D1(printk(KERN_DEBUG "end prepare_write(). nrpages %ldn", inode->i_mapping->nrpages));
  401. up(&f->sem);
  402. return ret;
  403. }
  405. int jffs2_commit_write (struct file *filp, struct page *pg, unsigned start, unsigned end)
  406. {
  407. /* Actually commit the write from the page cache page we're looking at.
  408.  * For now, we write the full page out each time. It sucks, but it's simple
  409.  */
  410. struct inode *inode = filp->f_dentry->d_inode;
  411. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  412. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  413. __u32 newsize = max_t(__u32, filp->f_dentry->d_inode->i_size, (pg->index << PAGE_CACHE_SHIFT) + end);
  414. __u32 file_ofs = (pg->index << PAGE_CACHE_SHIFT);
  415. __u32 writelen = min((__u32)PAGE_CACHE_SIZE, newsize - file_ofs);
  416. struct jffs2_raw_inode *ri;
  417. int ret = 0;
  418. ssize_t writtenlen = 0;
  420. D1(printk(KERN_DEBUG "jffs2_commit_write(): ino #%lu, page at 0x%lx, range %d-%d, nrpages %ldn", inode->i_ino, pg->index << PAGE_CACHE_SHIFT, start, end, filp->f_dentry->d_inode->i_mapping->nrpages));
  422. ri = jffs2_alloc_raw_inode();
  423. if (!ri)
  424. return -ENOMEM;
  426. while(writelen) {
  427. struct jffs2_full_dnode *fn;
  428. unsigned char *comprbuf = NULL;
  429. unsigned char comprtype = JFFS2_COMPR_NONE;
  430. __u32 phys_ofs, alloclen;
  431. __u32 datalen, cdatalen;
  433. D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%xn", writelen, file_ofs));
  435. ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL);
  436. if (ret) {
  437. SetPageError(pg);
  438. D1(printk(KERN_DEBUG "jffs2_reserve_space returned %dn", ret));
  439. break;
  440. }
  441. down(&f->sem);
  442. datalen = writelen;
  443. cdatalen = min(alloclen - sizeof(*ri), writelen);
  445. comprbuf = kmalloc(cdatalen, GFP_KERNEL);
  446. if (comprbuf) {
  447. comprtype = jffs2_compress(page_address(pg)+ (file_ofs & (PAGE_CACHE_SIZE-1)), comprbuf, &datalen, &cdatalen);
  448. }
  449. if (comprtype == JFFS2_COMPR_NONE) {
  450. /* Either compression failed, or the allocation of comprbuf failed */
  451. if (comprbuf)
  452. kfree(comprbuf);
  453. comprbuf = page_address(pg) + (file_ofs & (PAGE_CACHE_SIZE -1));
  454. datalen = cdatalen;
  455. }
  456. /* Now comprbuf points to the data to be written, be it compressed or not.
  457.    comprtype holds the compression type, and comprtype == JFFS2_COMPR_NONE means
  458.    that the comprbuf doesn't need to be kfree()d. 
  459. */
  461. ri->magic = JFFS2_MAGIC_BITMASK;
  462. ri->nodetype = JFFS2_NODETYPE_INODE;
  463. ri->totlen = sizeof(*ri) + cdatalen;
  464. ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);
  466. ri->ino = inode->i_ino;
  467. ri->version = ++f->highest_version;
  468. ri->mode = inode->i_mode;
  469. ri->uid = inode->i_uid;
  470. ri->gid = inode->i_gid;
  471. ri->isize = max((__u32)inode->i_size, file_ofs + datalen);
  472. ri->atime = ri->ctime = ri->mtime = CURRENT_TIME;
  473. ri->offset = file_ofs;
  474. ri->csize = cdatalen;
  475. ri->dsize = datalen;
  476. ri->compr = comprtype;
  477. ri->node_crc = crc32(0, ri, sizeof(*ri)-8);
  478. ri->data_crc = crc32(0, comprbuf, cdatalen);
  480. fn = jffs2_write_dnode(inode, ri, comprbuf, cdatalen, phys_ofs, NULL);
  482. jffs2_complete_reservation(c);
  484. if (comprtype != JFFS2_COMPR_NONE)
  485. kfree(comprbuf);
  487. if (IS_ERR(fn)) {
  488. ret = PTR_ERR(fn);
  489. up(&f->sem);
  490. SetPageError(pg);
  491. break;
  492. }
  493. ret = jffs2_add_full_dnode_to_inode(c, f, fn);
  494. if (f->metadata) {
  495. jffs2_mark_node_obsolete(c, f->metadata->raw);
  496. jffs2_free_full_dnode(f->metadata);
  497. f->metadata = NULL;
  498. }
  499. up(&f->sem);
  500. if (ret) {
  501. /* Eep */
  502. D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %dn", ret));
  503. jffs2_mark_node_obsolete(c, fn->raw);
  504. jffs2_free_full_dnode(fn);
  505. SetPageError(pg);
  506. break;
  507. }
  508. inode->i_size = ri->isize;
  509. inode->i_blocks = (inode->i_size + 511) >> 9;
  510. inode->i_ctime = inode->i_mtime = ri->ctime;
  511. if (!datalen) {
  512. printk(KERN_WARNING "Eep. We didn't actually write any bloody datan");
  513. ret = -EIO;
  514. SetPageError(pg);
  515. break;
  516. }
  517. D1(printk(KERN_DEBUG "increasing writtenlen by %dn", datalen));
  518. writtenlen += datalen;
  519. file_ofs += datalen;
  520. writelen -= datalen;
  521. }
  523. jffs2_free_raw_inode(ri);
  525. if (writtenlen < end) {
  526. /* generic_file_write has written more to the page cache than we've
  527.    actually written to the medium. Mark the page !Uptodate so that 
  528.    it gets reread */
  529. D1(printk(KERN_DEBUG "jffs2_commit_write(): Not all bytes written. Marking page !uptodaten"));
  530. SetPageError(pg);
  531. ClearPageUptodate(pg);
  532. }
  533. if (writtenlen <= start) {
  534. /* We didn't even get to the start of the affected part */
  535. ret = ret?ret:-ENOSPC;
  536. D1(printk(KERN_DEBUG "jffs2_commit_write(): Only %x bytes written to page. start (%x) not reached, returning %dn", writtenlen, start, ret));
  537. }
  538. writtenlen = min(end-start, writtenlen-start);
  540. D1(printk(KERN_DEBUG "jffs2_commit_write() returning %d. nrpages is %ldn",writtenlen?writtenlen:ret, inode->i_mapping->nrpages));
  541. return writtenlen?writtenlen:ret;
  542. }