write.c (c9d8f89d9816c1d16ada492aa547a4d692508c0d) write.c (dbae4c73f08b8a7980cc912954ade3d4c1fb6147)
1/*
2 * linux/fs/nfs/write.c
3 *
4 * Write file data over NFS.
5 *
6 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
7 */
8

--- 764 unchanged lines hidden (view full) ---

773 return RPC_PRIORITY_LOW;
774 }
775 return RPC_PRIORITY_NORMAL;
776}
777
778/*
779 * Set up the argument/result storage required for the RPC call.
780 */
1/*
2 * linux/fs/nfs/write.c
3 *
4 * Write file data over NFS.
5 *
6 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
7 */
8

--- 764 unchanged lines hidden (view full) ---

773 return RPC_PRIORITY_LOW;
774 }
775 return RPC_PRIORITY_NORMAL;
776}
777
778/*
779 * Set up the argument/result storage required for the RPC call.
780 */
781static void nfs_write_rpcsetup(struct nfs_page *req,
781static int nfs_write_rpcsetup(struct nfs_page *req,
782 struct nfs_write_data *data,
783 const struct rpc_call_ops *call_ops,
784 unsigned int count, unsigned int offset,
785 int how)
786{
787 struct inode *inode = req->wb_context->path.dentry->d_inode;
788 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
789 int priority = flush_task_priority(how);

--- 46 unchanged lines hidden (view full) ---

836 "(req %s/%Ld, %u bytes @ offset %Lu)\n",
837 data->task.tk_pid,
838 inode->i_sb->s_id,
839 (long long)NFS_FILEID(inode),
840 count,
841 (unsigned long long)data->args.offset);
842
843 task = rpc_run_task(&task_setup_data);
782 struct nfs_write_data *data,
783 const struct rpc_call_ops *call_ops,
784 unsigned int count, unsigned int offset,
785 int how)
786{
787 struct inode *inode = req->wb_context->path.dentry->d_inode;
788 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
789 int priority = flush_task_priority(how);

--- 46 unchanged lines hidden (view full) ---

836 "(req %s/%Ld, %u bytes @ offset %Lu)\n",
837 data->task.tk_pid,
838 inode->i_sb->s_id,
839 (long long)NFS_FILEID(inode),
840 count,
841 (unsigned long long)data->args.offset);
842
843 task = rpc_run_task(&task_setup_data);
844 if (!IS_ERR(task))
845 rpc_put_task(task);
844 if (IS_ERR(task))
845 return PTR_ERR(task);
846 rpc_put_task(task);
847 return 0;
846}
847
848/* If a nfs_flush_* function fails, it should remove reqs from @head and
849 * call this on each, which will prepare them to be retried on next
850 * writeback using standard nfs.
851 */
852static void nfs_redirty_request(struct nfs_page *req)
853{

--- 9 unchanged lines hidden (view full) ---

863static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
864{
865 struct nfs_page *req = nfs_list_entry(head->next);
866 struct page *page = req->wb_page;
867 struct nfs_write_data *data;
868 size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
869 unsigned int offset;
870 int requests = 0;
848}
849
850/* If a nfs_flush_* function fails, it should remove reqs from @head and
851 * call this on each, which will prepare them to be retried on next
852 * writeback using standard nfs.
853 */
854static void nfs_redirty_request(struct nfs_page *req)
855{

--- 9 unchanged lines hidden (view full) ---

865static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
866{
867 struct nfs_page *req = nfs_list_entry(head->next);
868 struct page *page = req->wb_page;
869 struct nfs_write_data *data;
870 size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
871 unsigned int offset;
872 int requests = 0;
873 int ret = 0;
871 LIST_HEAD(list);
872
873 nfs_list_remove_request(req);
874
875 nbytes = count;
876 do {
877 size_t len = min(nbytes, wsize);
878

--- 5 unchanged lines hidden (view full) ---

884 nbytes -= len;
885 } while (nbytes != 0);
886 atomic_set(&req->wb_complete, requests);
887
888 ClearPageError(page);
889 offset = 0;
890 nbytes = count;
891 do {
874 LIST_HEAD(list);
875
876 nfs_list_remove_request(req);
877
878 nbytes = count;
879 do {
880 size_t len = min(nbytes, wsize);
881

--- 5 unchanged lines hidden (view full) ---

887 nbytes -= len;
888 } while (nbytes != 0);
889 atomic_set(&req->wb_complete, requests);
890
891 ClearPageError(page);
892 offset = 0;
893 nbytes = count;
894 do {
895 int ret2;
896
892 data = list_entry(list.next, struct nfs_write_data, pages);
893 list_del_init(&data->pages);
894
895 data->pagevec[0] = page;
896
897 if (nbytes < wsize)
898 wsize = nbytes;
897 data = list_entry(list.next, struct nfs_write_data, pages);
898 list_del_init(&data->pages);
899
900 data->pagevec[0] = page;
901
902 if (nbytes < wsize)
903 wsize = nbytes;
899 nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
904 ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
900 wsize, offset, how);
905 wsize, offset, how);
906 if (ret == 0)
907 ret = ret2;
901 offset += wsize;
902 nbytes -= wsize;
903 } while (nbytes != 0);
904
908 offset += wsize;
909 nbytes -= wsize;
910 } while (nbytes != 0);
911
905 return 0;
912 return ret;
906
907out_bad:
908 while (!list_empty(&list)) {
909 data = list_entry(list.next, struct nfs_write_data, pages);
910 list_del(&data->pages);
911 nfs_writedata_release(data);
912 }
913 nfs_redirty_request(req);

--- 24 unchanged lines hidden (view full) ---

938 nfs_list_remove_request(req);
939 nfs_list_add_request(req, &data->pages);
940 ClearPageError(req->wb_page);
941 *pages++ = req->wb_page;
942 }
943 req = nfs_list_entry(data->pages.next);
944
945 /* Set up the argument struct */
913
914out_bad:
915 while (!list_empty(&list)) {
916 data = list_entry(list.next, struct nfs_write_data, pages);
917 list_del(&data->pages);
918 nfs_writedata_release(data);
919 }
920 nfs_redirty_request(req);

--- 24 unchanged lines hidden (view full) ---

945 nfs_list_remove_request(req);
946 nfs_list_add_request(req, &data->pages);
947 ClearPageError(req->wb_page);
948 *pages++ = req->wb_page;
949 }
950 req = nfs_list_entry(data->pages.next);
951
952 /* Set up the argument struct */
946 nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
947
948 return 0;
953 return nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
949 out_bad:
950 while (!list_empty(head)) {
951 req = nfs_list_entry(head->next);
952 nfs_list_remove_request(req);
953 nfs_redirty_request(req);
954 }
955 return -ENOMEM;
956}

--- 221 unchanged lines hidden (view full) ---

1178
1179 put_nfs_open_context(wdata->args.context);
1180 nfs_commit_free(wdata);
1181}
1182
1183/*
1184 * Set up the argument/result storage required for the RPC call.
1185 */
954 out_bad:
955 while (!list_empty(head)) {
956 req = nfs_list_entry(head->next);
957 nfs_list_remove_request(req);
958 nfs_redirty_request(req);
959 }
960 return -ENOMEM;
961}

--- 221 unchanged lines hidden (view full) ---

1183
1184 put_nfs_open_context(wdata->args.context);
1185 nfs_commit_free(wdata);
1186}
1187
1188/*
1189 * Set up the argument/result storage required for the RPC call.
1190 */
1186static void nfs_commit_rpcsetup(struct list_head *head,
1191static int nfs_commit_rpcsetup(struct list_head *head,
1187 struct nfs_write_data *data,
1188 int how)
1189{
1190 struct nfs_page *first = nfs_list_entry(head->next);
1191 struct inode *inode = first->wb_context->path.dentry->d_inode;
1192 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
1193 int priority = flush_task_priority(how);
1194 struct rpc_task *task;

--- 32 unchanged lines hidden (view full) ---

1227 nfs_fattr_init(&data->fattr);
1228
1229 /* Set up the initial task struct. */
1230 NFS_PROTO(inode)->commit_setup(data, &msg);
1231
1232 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
1233
1234 task = rpc_run_task(&task_setup_data);
1192 struct nfs_write_data *data,
1193 int how)
1194{
1195 struct nfs_page *first = nfs_list_entry(head->next);
1196 struct inode *inode = first->wb_context->path.dentry->d_inode;
1197 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
1198 int priority = flush_task_priority(how);
1199 struct rpc_task *task;

--- 32 unchanged lines hidden (view full) ---

1232 nfs_fattr_init(&data->fattr);
1233
1234 /* Set up the initial task struct. */
1235 NFS_PROTO(inode)->commit_setup(data, &msg);
1236
1237 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
1238
1239 task = rpc_run_task(&task_setup_data);
1235 if (!IS_ERR(task))
1236 rpc_put_task(task);
1240 if (IS_ERR(task))
1241 return PTR_ERR(task);
1242 rpc_put_task(task);
1243 return 0;
1237}
1238
1239/*
1240 * Commit dirty pages
1241 */
1242static int
1243nfs_commit_list(struct inode *inode, struct list_head *head, int how)
1244{
1245 struct nfs_write_data *data;
1246 struct nfs_page *req;
1247
1248 data = nfs_commitdata_alloc();
1249
1250 if (!data)
1251 goto out_bad;
1252
1253 /* Set up the argument struct */
1244}
1245
1246/*
1247 * Commit dirty pages
1248 */
1249static int
1250nfs_commit_list(struct inode *inode, struct list_head *head, int how)
1251{
1252 struct nfs_write_data *data;
1253 struct nfs_page *req;
1254
1255 data = nfs_commitdata_alloc();
1256
1257 if (!data)
1258 goto out_bad;
1259
1260 /* Set up the argument struct */
1254 nfs_commit_rpcsetup(head, data, how);
1255
1256 return 0;
1261 return nfs_commit_rpcsetup(head, data, how);
1257 out_bad:
1258 while (!list_empty(head)) {
1259 req = nfs_list_entry(head->next);
1260 nfs_list_remove_request(req);
1261 nfs_mark_request_commit(req);
1262 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
1263 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1264 BDI_RECLAIMABLE);

--- 324 unchanged lines hidden --- 		1262 out_bad:
1263 while (!list_empty(head)) {
1264 req = nfs_list_entry(head->next);
1265 nfs_list_remove_request(req);
1266 nfs_mark_request_commit(req);
1267 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
1268 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1269 BDI_RECLAIMABLE);

--- 324 unchanged lines hidden ---