file.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831
  1. /*
  2. FUSE: Filesystem in Userspace
  3. Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
  4. This program can be distributed under the terms of the GNU GPL.
  5. See the file COPYING.
  6. */
  7. #include "fuse_i.h"
  8. #include <linux/pagemap.h>
  9. #include <linux/slab.h>
  10. #include <linux/kernel.h>
  11. static const struct file_operations fuse_direct_io_file_operations;
  12. static int fuse_send_open(struct inode *inode, struct file *file, int isdir,
  13. struct fuse_open_out *outargp)
  14. {
  15. struct fuse_conn *fc = get_fuse_conn(inode);
  16. struct fuse_open_in inarg;
  17. struct fuse_req *req;
  18. int err;
  19. req = fuse_get_req(fc);
  20. if (IS_ERR(req))
  21. return PTR_ERR(req);
  22. memset(&inarg, 0, sizeof(inarg));
  23. inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
  24. req->in.h.opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
  25. req->in.h.nodeid = get_node_id(inode);
  26. req->in.numargs = 1;
  27. req->in.args[0].size = sizeof(inarg);
  28. req->in.args[0].value = &inarg;
  29. req->out.numargs = 1;
  30. req->out.args[0].size = sizeof(*outargp);
  31. req->out.args[0].value = outargp;
  32. request_send(fc, req);
  33. err = req->out.h.error;
  34. fuse_put_request(fc, req);
  35. return err;
  36. }
  37. struct fuse_file *fuse_file_alloc(void)
  38. {
  39. struct fuse_file *ff;
  40. ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL);
  41. if (ff) {
  42. ff->reserved_req = fuse_request_alloc();
  43. if (!ff->reserved_req) {
  44. kfree(ff);
  45. ff = NULL;
  46. }
  47. }
  48. return ff;
  49. }
  50. void fuse_file_free(struct fuse_file *ff)
  51. {
  52. fuse_request_free(ff->reserved_req);
  53. kfree(ff);
  54. }
  55. void fuse_finish_open(struct inode *inode, struct file *file,
  56. struct fuse_file *ff, struct fuse_open_out *outarg)
  57. {
  58. if (outarg->open_flags & FOPEN_DIRECT_IO)
  59. file->f_op = &fuse_direct_io_file_operations;
  60. if (!(outarg->open_flags & FOPEN_KEEP_CACHE))
  61. invalidate_mapping_pages(inode->i_mapping, 0, -1);
  62. ff->fh = outarg->fh;
  63. file->private_data = ff;
  64. }
  65. int fuse_open_common(struct inode *inode, struct file *file, int isdir)
  66. {
  67. struct fuse_open_out outarg;
  68. struct fuse_file *ff;
  69. int err;
  70. /* VFS checks this, but only _after_ ->open() */
  71. if (file->f_flags & O_DIRECT)
  72. return -EINVAL;
  73. err = generic_file_open(inode, file);
  74. if (err)
  75. return err;
  76. /* If opening the root node, no lookup has been performed on
  77. it, so the attributes must be refreshed */
  78. if (get_node_id(inode) == FUSE_ROOT_ID) {
  79. err = fuse_do_getattr(inode);
  80. if (err)
  81. return err;
  82. }
  83. ff = fuse_file_alloc();
  84. if (!ff)
  85. return -ENOMEM;
  86. err = fuse_send_open(inode, file, isdir, &outarg);
  87. if (err)
  88. fuse_file_free(ff);
  89. else {
  90. if (isdir)
  91. outarg.open_flags &= ~FOPEN_DIRECT_IO;
  92. fuse_finish_open(inode, file, ff, &outarg);
  93. }
  94. return err;
  95. }
  96. struct fuse_req *fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags,
  97. int opcode)
  98. {
  99. struct fuse_req *req = ff->reserved_req;
  100. struct fuse_release_in *inarg = &req->misc.release_in;
  101. inarg->fh = ff->fh;
  102. inarg->flags = flags;
  103. req->in.h.opcode = opcode;
  104. req->in.h.nodeid = nodeid;
  105. req->in.numargs = 1;
  106. req->in.args[0].size = sizeof(struct fuse_release_in);
  107. req->in.args[0].value = inarg;
  108. kfree(ff);
  109. return req;
  110. }
  111. int fuse_release_common(struct inode *inode, struct file *file, int isdir)
  112. {
  113. struct fuse_file *ff = file->private_data;
  114. if (ff) {
  115. struct fuse_conn *fc = get_fuse_conn(inode);
  116. struct fuse_req *req;
  117. req = fuse_release_fill(ff, get_node_id(inode), file->f_flags,
  118. isdir ? FUSE_RELEASEDIR : FUSE_RELEASE);
  119. /* Hold vfsmount and dentry until release is finished */
  120. req->vfsmount = mntget(file->f_path.mnt);
  121. req->dentry = dget(file->f_path.dentry);
  122. request_send_background(fc, req);
  123. }
  124. /* Return value is ignored by VFS */
  125. return 0;
  126. }
  127. static int fuse_open(struct inode *inode, struct file *file)
  128. {
  129. return fuse_open_common(inode, file, 0);
  130. }
  131. static int fuse_release(struct inode *inode, struct file *file)
  132. {
  133. return fuse_release_common(inode, file, 0);
  134. }
  135. /*
  136. * Scramble the ID space with XTEA, so that the value of the files_struct
  137. * pointer is not exposed to userspace.
  138. */
  139. static u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id)
  140. {
  141. u32 *k = fc->scramble_key;
  142. u64 v = (unsigned long) id;
  143. u32 v0 = v;
  144. u32 v1 = v >> 32;
  145. u32 sum = 0;
  146. int i;
  147. for (i = 0; i < 32; i++) {
  148. v0 += ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
  149. sum += 0x9E3779B9;
  150. v1 += ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]);
  151. }
  152. return (u64) v0 + ((u64) v1 << 32);
  153. }
  154. static int fuse_flush(struct file *file, fl_owner_t id)
  155. {
  156. struct inode *inode = file->f_path.dentry->d_inode;
  157. struct fuse_conn *fc = get_fuse_conn(inode);
  158. struct fuse_file *ff = file->private_data;
  159. struct fuse_req *req;
  160. struct fuse_flush_in inarg;
  161. int err;
  162. if (is_bad_inode(inode))
  163. return -EIO;
  164. if (fc->no_flush)
  165. return 0;
  166. req = fuse_get_req_nofail(fc, file);
  167. memset(&inarg, 0, sizeof(inarg));
  168. inarg.fh = ff->fh;
  169. inarg.lock_owner = fuse_lock_owner_id(fc, id);
  170. req->in.h.opcode = FUSE_FLUSH;
  171. req->in.h.nodeid = get_node_id(inode);
  172. req->in.numargs = 1;
  173. req->in.args[0].size = sizeof(inarg);
  174. req->in.args[0].value = &inarg;
  175. req->force = 1;
  176. request_send(fc, req);
  177. err = req->out.h.error;
  178. fuse_put_request(fc, req);
  179. if (err == -ENOSYS) {
  180. fc->no_flush = 1;
  181. err = 0;
  182. }
  183. return err;
  184. }
  185. int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
  186. int isdir)
  187. {
  188. struct inode *inode = de->d_inode;
  189. struct fuse_conn *fc = get_fuse_conn(inode);
  190. struct fuse_file *ff = file->private_data;
  191. struct fuse_req *req;
  192. struct fuse_fsync_in inarg;
  193. int err;
  194. if (is_bad_inode(inode))
  195. return -EIO;
  196. if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir))
  197. return 0;
  198. req = fuse_get_req(fc);
  199. if (IS_ERR(req))
  200. return PTR_ERR(req);
  201. memset(&inarg, 0, sizeof(inarg));
  202. inarg.fh = ff->fh;
  203. inarg.fsync_flags = datasync ? 1 : 0;
  204. req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;
  205. req->in.h.nodeid = get_node_id(inode);
  206. req->in.numargs = 1;
  207. req->in.args[0].size = sizeof(inarg);
  208. req->in.args[0].value = &inarg;
  209. request_send(fc, req);
  210. err = req->out.h.error;
  211. fuse_put_request(fc, req);
  212. if (err == -ENOSYS) {
  213. if (isdir)
  214. fc->no_fsyncdir = 1;
  215. else
  216. fc->no_fsync = 1;
  217. err = 0;
  218. }
  219. return err;
  220. }
  221. static int fuse_fsync(struct file *file, struct dentry *de, int datasync)
  222. {
  223. return fuse_fsync_common(file, de, datasync, 0);
  224. }
  225. void fuse_read_fill(struct fuse_req *req, struct file *file,
  226. struct inode *inode, loff_t pos, size_t count, int opcode)
  227. {
  228. struct fuse_file *ff = file->private_data;
  229. struct fuse_read_in *inarg = &req->misc.read_in;
  230. inarg->fh = ff->fh;
  231. inarg->offset = pos;
  232. inarg->size = count;
  233. req->in.h.opcode = opcode;
  234. req->in.h.nodeid = get_node_id(inode);
  235. req->in.numargs = 1;
  236. req->in.args[0].size = sizeof(struct fuse_read_in);
  237. req->in.args[0].value = inarg;
  238. req->out.argpages = 1;
  239. req->out.argvar = 1;
  240. req->out.numargs = 1;
  241. req->out.args[0].size = count;
  242. }
  243. static size_t fuse_send_read(struct fuse_req *req, struct file *file,
  244. struct inode *inode, loff_t pos, size_t count)
  245. {
  246. struct fuse_conn *fc = get_fuse_conn(inode);
  247. fuse_read_fill(req, file, inode, pos, count, FUSE_READ);
  248. request_send(fc, req);
  249. return req->out.args[0].size;
  250. }
  251. static int fuse_readpage(struct file *file, struct page *page)
  252. {
  253. struct inode *inode = page->mapping->host;
  254. struct fuse_conn *fc = get_fuse_conn(inode);
  255. struct fuse_req *req;
  256. int err;
  257. err = -EIO;
  258. if (is_bad_inode(inode))
  259. goto out;
  260. req = fuse_get_req(fc);
  261. err = PTR_ERR(req);
  262. if (IS_ERR(req))
  263. goto out;
  264. req->out.page_zeroing = 1;
  265. req->num_pages = 1;
  266. req->pages[0] = page;
  267. fuse_send_read(req, file, inode, page_offset(page), PAGE_CACHE_SIZE);
  268. err = req->out.h.error;
  269. fuse_put_request(fc, req);
  270. if (!err)
  271. SetPageUptodate(page);
  272. fuse_invalidate_attr(inode); /* atime changed */
  273. out:
  274. unlock_page(page);
  275. return err;
  276. }
  277. static void fuse_readpages_end(struct fuse_conn *fc, struct fuse_req *req)
  278. {
  279. int i;
  280. fuse_invalidate_attr(req->pages[0]->mapping->host); /* atime changed */
  281. for (i = 0; i < req->num_pages; i++) {
  282. struct page *page = req->pages[i];
  283. if (!req->out.h.error)
  284. SetPageUptodate(page);
  285. else
  286. SetPageError(page);
  287. unlock_page(page);
  288. }
  289. fuse_put_request(fc, req);
  290. }
  291. static void fuse_send_readpages(struct fuse_req *req, struct file *file,
  292. struct inode *inode)
  293. {
  294. struct fuse_conn *fc = get_fuse_conn(inode);
  295. loff_t pos = page_offset(req->pages[0]);
  296. size_t count = req->num_pages << PAGE_CACHE_SHIFT;
  297. req->out.page_zeroing = 1;
  298. fuse_read_fill(req, file, inode, pos, count, FUSE_READ);
  299. if (fc->async_read) {
  300. get_file(file);
  301. req->file = file;
  302. req->end = fuse_readpages_end;
  303. request_send_background(fc, req);
  304. } else {
  305. request_send(fc, req);
  306. fuse_readpages_end(fc, req);
  307. }
  308. }
  309. struct fuse_readpages_data {
  310. struct fuse_req *req;
  311. struct file *file;
  312. struct inode *inode;
  313. };
  314. static int fuse_readpages_fill(void *_data, struct page *page)
  315. {
  316. struct fuse_readpages_data *data = _data;
  317. struct fuse_req *req = data->req;
  318. struct inode *inode = data->inode;
  319. struct fuse_conn *fc = get_fuse_conn(inode);
  320. if (req->num_pages &&
  321. (req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
  322. (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read ||
  323. req->pages[req->num_pages - 1]->index + 1 != page->index)) {
  324. fuse_send_readpages(req, data->file, inode);
  325. data->req = req = fuse_get_req(fc);
  326. if (IS_ERR(req)) {
  327. unlock_page(page);
  328. return PTR_ERR(req);
  329. }
  330. }
  331. req->pages[req->num_pages] = page;
  332. req->num_pages ++;
  333. return 0;
  334. }
  335. static int fuse_readpages(struct file *file, struct address_space *mapping,
  336. struct list_head *pages, unsigned nr_pages)
  337. {
  338. struct inode *inode = mapping->host;
  339. struct fuse_conn *fc = get_fuse_conn(inode);
  340. struct fuse_readpages_data data;
  341. int err;
  342. err = -EIO;
  343. if (is_bad_inode(inode))
  344. goto out;
  345. data.file = file;
  346. data.inode = inode;
  347. data.req = fuse_get_req(fc);
  348. err = PTR_ERR(data.req);
  349. if (IS_ERR(data.req))
  350. goto out;
  351. err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data);
  352. if (!err) {
  353. if (data.req->num_pages)
  354. fuse_send_readpages(data.req, file, inode);
  355. else
  356. fuse_put_request(fc, data.req);
  357. }
  358. out:
  359. return err;
  360. }
  361. static size_t fuse_send_write(struct fuse_req *req, struct file *file,
  362. struct inode *inode, loff_t pos, size_t count)
  363. {
  364. struct fuse_conn *fc = get_fuse_conn(inode);
  365. struct fuse_file *ff = file->private_data;
  366. struct fuse_write_in inarg;
  367. struct fuse_write_out outarg;
  368. memset(&inarg, 0, sizeof(struct fuse_write_in));
  369. inarg.fh = ff->fh;
  370. inarg.offset = pos;
  371. inarg.size = count;
  372. req->in.h.opcode = FUSE_WRITE;
  373. req->in.h.nodeid = get_node_id(inode);
  374. req->in.argpages = 1;
  375. req->in.numargs = 2;
  376. req->in.args[0].size = sizeof(struct fuse_write_in);
  377. req->in.args[0].value = &inarg;
  378. req->in.args[1].size = count;
  379. req->out.numargs = 1;
  380. req->out.args[0].size = sizeof(struct fuse_write_out);
  381. req->out.args[0].value = &outarg;
  382. request_send(fc, req);
  383. return outarg.size;
  384. }
  385. static int fuse_prepare_write(struct file *file, struct page *page,
  386. unsigned offset, unsigned to)
  387. {
  388. /* No op */
  389. return 0;
  390. }
  391. static int fuse_commit_write(struct file *file, struct page *page,
  392. unsigned offset, unsigned to)
  393. {
  394. int err;
  395. size_t nres;
  396. unsigned count = to - offset;
  397. struct inode *inode = page->mapping->host;
  398. struct fuse_conn *fc = get_fuse_conn(inode);
  399. loff_t pos = page_offset(page) + offset;
  400. struct fuse_req *req;
  401. if (is_bad_inode(inode))
  402. return -EIO;
  403. req = fuse_get_req(fc);
  404. if (IS_ERR(req))
  405. return PTR_ERR(req);
  406. req->num_pages = 1;
  407. req->pages[0] = page;
  408. req->page_offset = offset;
  409. nres = fuse_send_write(req, file, inode, pos, count);
  410. err = req->out.h.error;
  411. fuse_put_request(fc, req);
  412. if (!err && nres != count)
  413. err = -EIO;
  414. if (!err) {
  415. pos += count;
  416. spin_lock(&fc->lock);
  417. if (pos > inode->i_size)
  418. i_size_write(inode, pos);
  419. spin_unlock(&fc->lock);
  420. if (offset == 0 && to == PAGE_CACHE_SIZE)
  421. SetPageUptodate(page);
  422. }
  423. fuse_invalidate_attr(inode);
  424. return err;
  425. }
  426. static void fuse_release_user_pages(struct fuse_req *req, int write)
  427. {
  428. unsigned i;
  429. for (i = 0; i < req->num_pages; i++) {
  430. struct page *page = req->pages[i];
  431. if (write)
  432. set_page_dirty_lock(page);
  433. put_page(page);
  434. }
  435. }
  436. static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf,
  437. unsigned nbytes, int write)
  438. {
  439. unsigned long user_addr = (unsigned long) buf;
  440. unsigned offset = user_addr & ~PAGE_MASK;
  441. int npages;
  442. /* This doesn't work with nfsd */
  443. if (!current->mm)
  444. return -EPERM;
  445. nbytes = min(nbytes, (unsigned) FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
  446. npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
  447. npages = min(max(npages, 1), FUSE_MAX_PAGES_PER_REQ);
  448. down_read(&current->mm->mmap_sem);
  449. npages = get_user_pages(current, current->mm, user_addr, npages, write,
  450. 0, req->pages, NULL);
  451. up_read(&current->mm->mmap_sem);
  452. if (npages < 0)
  453. return npages;
  454. req->num_pages = npages;
  455. req->page_offset = offset;
  456. return 0;
  457. }
  458. static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
  459. size_t count, loff_t *ppos, int write)
  460. {
  461. struct inode *inode = file->f_path.dentry->d_inode;
  462. struct fuse_conn *fc = get_fuse_conn(inode);
  463. size_t nmax = write ? fc->max_write : fc->max_read;
  464. loff_t pos = *ppos;
  465. ssize_t res = 0;
  466. struct fuse_req *req;
  467. if (is_bad_inode(inode))
  468. return -EIO;
  469. req = fuse_get_req(fc);
  470. if (IS_ERR(req))
  471. return PTR_ERR(req);
  472. while (count) {
  473. size_t nres;
  474. size_t nbytes = min(count, nmax);
  475. int err = fuse_get_user_pages(req, buf, nbytes, !write);
  476. if (err) {
  477. res = err;
  478. break;
  479. }
  480. nbytes = (req->num_pages << PAGE_SHIFT) - req->page_offset;
  481. nbytes = min(count, nbytes);
  482. if (write)
  483. nres = fuse_send_write(req, file, inode, pos, nbytes);
  484. else
  485. nres = fuse_send_read(req, file, inode, pos, nbytes);
  486. fuse_release_user_pages(req, !write);
  487. if (req->out.h.error) {
  488. if (!res)
  489. res = req->out.h.error;
  490. break;
  491. } else if (nres > nbytes) {
  492. res = -EIO;
  493. break;
  494. }
  495. count -= nres;
  496. res += nres;
  497. pos += nres;
  498. buf += nres;
  499. if (nres != nbytes)
  500. break;
  501. if (count) {
  502. fuse_put_request(fc, req);
  503. req = fuse_get_req(fc);
  504. if (IS_ERR(req))
  505. break;
  506. }
  507. }
  508. fuse_put_request(fc, req);
  509. if (res > 0) {
  510. if (write) {
  511. spin_lock(&fc->lock);
  512. if (pos > inode->i_size)
  513. i_size_write(inode, pos);
  514. spin_unlock(&fc->lock);
  515. }
  516. *ppos = pos;
  517. }
  518. fuse_invalidate_attr(inode);
  519. return res;
  520. }
  521. static ssize_t fuse_direct_read(struct file *file, char __user *buf,
  522. size_t count, loff_t *ppos)
  523. {
  524. return fuse_direct_io(file, buf, count, ppos, 0);
  525. }
  526. static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
  527. size_t count, loff_t *ppos)
  528. {
  529. struct inode *inode = file->f_path.dentry->d_inode;
  530. ssize_t res;
  531. /* Don't allow parallel writes to the same file */
  532. mutex_lock(&inode->i_mutex);
  533. res = fuse_direct_io(file, buf, count, ppos, 1);
  534. mutex_unlock(&inode->i_mutex);
  535. return res;
  536. }
  537. static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
  538. {
  539. if ((vma->vm_flags & VM_SHARED)) {
  540. if ((vma->vm_flags & VM_WRITE))
  541. return -ENODEV;
  542. else
  543. vma->vm_flags &= ~VM_MAYWRITE;
  544. }
  545. return generic_file_mmap(file, vma);
  546. }
  547. static int fuse_set_page_dirty(struct page *page)
  548. {
  549. printk("fuse_set_page_dirty: should not happen\n");
  550. dump_stack();
  551. return 0;
  552. }
  553. static int convert_fuse_file_lock(const struct fuse_file_lock *ffl,
  554. struct file_lock *fl)
  555. {
  556. switch (ffl->type) {
  557. case F_UNLCK:
  558. break;
  559. case F_RDLCK:
  560. case F_WRLCK:
  561. if (ffl->start > OFFSET_MAX || ffl->end > OFFSET_MAX ||
  562. ffl->end < ffl->start)
  563. return -EIO;
  564. fl->fl_start = ffl->start;
  565. fl->fl_end = ffl->end;
  566. fl->fl_pid = ffl->pid;
  567. break;
  568. default:
  569. return -EIO;
  570. }
  571. fl->fl_type = ffl->type;
  572. return 0;
  573. }
  574. static void fuse_lk_fill(struct fuse_req *req, struct file *file,
  575. const struct file_lock *fl, int opcode, pid_t pid)
  576. {
  577. struct inode *inode = file->f_path.dentry->d_inode;
  578. struct fuse_conn *fc = get_fuse_conn(inode);
  579. struct fuse_file *ff = file->private_data;
  580. struct fuse_lk_in *arg = &req->misc.lk_in;
  581. arg->fh = ff->fh;
  582. arg->owner = fuse_lock_owner_id(fc, fl->fl_owner);
  583. arg->lk.start = fl->fl_start;
  584. arg->lk.end = fl->fl_end;
  585. arg->lk.type = fl->fl_type;
  586. arg->lk.pid = pid;
  587. req->in.h.opcode = opcode;
  588. req->in.h.nodeid = get_node_id(inode);
  589. req->in.numargs = 1;
  590. req->in.args[0].size = sizeof(*arg);
  591. req->in.args[0].value = arg;
  592. }
  593. static int fuse_getlk(struct file *file, struct file_lock *fl)
  594. {
  595. struct inode *inode = file->f_path.dentry->d_inode;
  596. struct fuse_conn *fc = get_fuse_conn(inode);
  597. struct fuse_req *req;
  598. struct fuse_lk_out outarg;
  599. int err;
  600. req = fuse_get_req(fc);
  601. if (IS_ERR(req))
  602. return PTR_ERR(req);
  603. fuse_lk_fill(req, file, fl, FUSE_GETLK, 0);
  604. req->out.numargs = 1;
  605. req->out.args[0].size = sizeof(outarg);
  606. req->out.args[0].value = &outarg;
  607. request_send(fc, req);
  608. err = req->out.h.error;
  609. fuse_put_request(fc, req);
  610. if (!err)
  611. err = convert_fuse_file_lock(&outarg.lk, fl);
  612. return err;
  613. }
  614. static int fuse_setlk(struct file *file, struct file_lock *fl)
  615. {
  616. struct inode *inode = file->f_path.dentry->d_inode;
  617. struct fuse_conn *fc = get_fuse_conn(inode);
  618. struct fuse_req *req;
  619. int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
  620. pid_t pid = fl->fl_type != F_UNLCK ? current->tgid : 0;
  621. int err;
  622. /* Unlock on close is handled by the flush method */
  623. if (fl->fl_flags & FL_CLOSE)
  624. return 0;
  625. req = fuse_get_req(fc);
  626. if (IS_ERR(req))
  627. return PTR_ERR(req);
  628. fuse_lk_fill(req, file, fl, opcode, pid);
  629. request_send(fc, req);
  630. err = req->out.h.error;
  631. /* locking is restartable */
  632. if (err == -EINTR)
  633. err = -ERESTARTSYS;
  634. fuse_put_request(fc, req);
  635. return err;
  636. }
  637. static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
  638. {
  639. struct inode *inode = file->f_path.dentry->d_inode;
  640. struct fuse_conn *fc = get_fuse_conn(inode);
  641. int err;
  642. if (cmd == F_GETLK) {
  643. if (fc->no_lock) {
  644. if (!posix_test_lock(file, fl, fl))
  645. fl->fl_type = F_UNLCK;
  646. err = 0;
  647. } else
  648. err = fuse_getlk(file, fl);
  649. } else {
  650. if (fc->no_lock)
  651. err = posix_lock_file_wait(file, fl);
  652. else
  653. err = fuse_setlk(file, fl);
  654. }
  655. return err;
  656. }
  657. static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
  658. {
  659. struct inode *inode = mapping->host;
  660. struct fuse_conn *fc = get_fuse_conn(inode);
  661. struct fuse_req *req;
  662. struct fuse_bmap_in inarg;
  663. struct fuse_bmap_out outarg;
  664. int err;
  665. if (!inode->i_sb->s_bdev || fc->no_bmap)
  666. return 0;
  667. req = fuse_get_req(fc);
  668. if (IS_ERR(req))
  669. return 0;
  670. memset(&inarg, 0, sizeof(inarg));
  671. inarg.block = block;
  672. inarg.blocksize = inode->i_sb->s_blocksize;
  673. req->in.h.opcode = FUSE_BMAP;
  674. req->in.h.nodeid = get_node_id(inode);
  675. req->in.numargs = 1;
  676. req->in.args[0].size = sizeof(inarg);
  677. req->in.args[0].value = &inarg;
  678. req->out.numargs = 1;
  679. req->out.args[0].size = sizeof(outarg);
  680. req->out.args[0].value = &outarg;
  681. request_send(fc, req);
  682. err = req->out.h.error;
  683. fuse_put_request(fc, req);
  684. if (err == -ENOSYS)
  685. fc->no_bmap = 1;
  686. return err ? 0 : outarg.block;
  687. }
  688. static const struct file_operations fuse_file_operations = {
  689. .llseek = generic_file_llseek,
  690. .read = do_sync_read,
  691. .aio_read = generic_file_aio_read,
  692. .write = do_sync_write,
  693. .aio_write = generic_file_aio_write,
  694. .mmap = fuse_file_mmap,
  695. .open = fuse_open,
  696. .flush = fuse_flush,
  697. .release = fuse_release,
  698. .fsync = fuse_fsync,
  699. .lock = fuse_file_lock,
  700. .sendfile = generic_file_sendfile,
  701. };
  702. static const struct file_operations fuse_direct_io_file_operations = {
  703. .llseek = generic_file_llseek,
  704. .read = fuse_direct_read,
  705. .write = fuse_direct_write,
  706. .open = fuse_open,
  707. .flush = fuse_flush,
  708. .release = fuse_release,
  709. .fsync = fuse_fsync,
  710. .lock = fuse_file_lock,
  711. /* no mmap and sendfile */
  712. };
  713. static const struct address_space_operations fuse_file_aops = {
  714. .readpage = fuse_readpage,
  715. .prepare_write = fuse_prepare_write,
  716. .commit_write = fuse_commit_write,
  717. .readpages = fuse_readpages,
  718. .set_page_dirty = fuse_set_page_dirty,
  719. .bmap = fuse_bmap,
  720. };
  721. void fuse_init_file_inode(struct inode *inode)
  722. {
  723. inode->i_fop = &fuse_file_operations;
  724. inode->i_data.a_ops = &fuse_file_aops;
  725. }