From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hans Verkuil Subject: Re: [PATCH v2 8/9] [media] handle 64-bit time_t in v4l2_buffer Date: Fri, 18 Sep 2015 09:18:45 +0200 Message-ID: <55FBBAD5.4010002@xs4all.nl> References: <1442524780-781677-1-git-send-email-arnd@arndb.de> <1442524780-781677-9-git-send-email-arnd@arndb.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1442524780-781677-9-git-send-email-arnd@arndb.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: y2038-bounces@lists.linaro.org Sender: "Y2038" To: Arnd Bergmann , linux-media@vger.kernel.org Cc: y2038@lists.linaro.org, linux-api@vger.kernel.org, linux-samsung-soc@vger.kernel.org, linux-kernel@vger.kernel.org, Mauro Carvalho Chehab List-Id: linux-api@vger.kernel.org SGkgQXJuZCwKClRoYW5rcyBvbmNlIGFnYWluIGZvciB3b3JraW5nIG9uIHRoaXMhIFVuZm9ydHVu YXRlbHksIHRoaXMgYXBwcm9hY2ggd29uJ3QKd29yaywgc2VlIG15IGNvbW1lbnRzIGJlbG93LgoK QlRXLCBJIHdvdWxkIGV4cGVjdCB0byBzZWUgY29tcGlsZSBlcnJvcnMgd2hlbiBjb21waWxpbmcg Zm9yIDMyIGJpdC4gRGlkCnlvdSB0cnkgdGhhdD8KCk9uIDA5LzE3LzIwMTUgMTE6MTkgUE0sIEFy bmQgQmVyZ21hbm4gd3JvdGU6Cj4gVGhpcyBpcyB0aGUgZmluYWwgY2hhbmdlIHRvIGVuYWJsZSB1 c2VyIHNwYWNlIHdpdGggNjQtYml0IHRpbWVfdAo+IGluIHRoZSBjb3JlIHY0bDIgY29kZS4KPiAK PiBGb3VyIGlvY3RscyBhcmUgYWZmZWN0ZWQgaGVyZTogVklESU9DX1FVRVJZQlVGLCBWSURJT0Nf UUJVRiwKPiBWSURJT0NfRFFCVUYsIGFuZCBWSURJT0NfUFJFUEFSRV9CVUYuIEFsbCBvZiB0aGVt IHBhc3MgYQo+IHN0cnVjdCB2NGwyX2J1ZmZlciwgd2hpY2ggY2FuIGVpdGhlciBjb250YWluIGEg MzItYml0IHRpbWVfdAo+IG9yIGEgNjQtYml0IHRpbWUgb24gMzItYml0IGFyY2hpdGVjdHVyZXMu Cj4gCj4gSW4gdGhpcyBwYXRjaCwgd2UgcmVkZWZpbmUgdGhlIGluLWtlcm5lbCB2ZXJzaW9uIG9m IHRoaXMgc3RydWN0dXJlCj4gdG8gdXNlIHRoZSA2NC1iaXQgX19zNjQgdHlwZSB0aHJvdWdoIHRo ZSB1c2Ugb2YgdjRsMl90aW1ldmFsLgo+IFRoaXMgbWVhbnMgdGhlIG5vcm1hbCBpb2N0bCBoYW5k bGluZyBub3cgYXNzdW1lcyA2NC1iaXQgdGltZV90Cj4gYW5kIHNvIHdlIGhhdmUgdG8gYWRkIHN1 cHBvcnQgZm9yIDMyLWJpdCB0aW1lX3QgaW4gbmV3IGhhbmRsZXJzLgo+IAo+IFRoaXMgaXMgc29t ZXdoYXQgc2ltaWxhciB0byB0aGUgMzItYml0IGNvbXBhdCBoYW5kbGluZyBvbiA2NC1iaXQKPiBh cmNoaXRlY3R1cmVzLCBidXQgdGhvc2UgYWxzbyBoYXZlIHRvIG1vZGlmeSBvdGhlciBmaWVsZHMg b2YKPiB0aGUgc3RydWN0dXJlLiBGb3Igbm93LCBJIGxlYXZlIHRoYXQgY29tcGF0IGNvZGUgYWxv bmUsIGFzIGl0Cj4gaGFuZGxlcyB0aGUgbm9ybWFsIGNhc2UgKDMyLWJpdCBjb21wYXRfdGltZV90 KSBjb3JyZWN0bHksIHRoaXMKPiBoYXMgdG8gYmUgZG9uZSBhcyBhIGZvbGxvdy11cC4KPiAKPiBT aWduZWQtb2ZmLWJ5OiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFybmRiLmRlPgo+IC0tLQo+ICBkcml2 ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWlvY3RsLmMgfCAxNzQgKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrLS0KPiAgaW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oICAgICAg IHwgIDM0ICsrKysrKy0KPiAgMiBmaWxlcyBjaGFuZ2VkLCAxOTkgaW5zZXJ0aW9ucygrKSwgOSBk ZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdjRs Mi1pb2N0bC5jIGIvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdjRsMi1pb2N0bC5jCj4gaW5kZXgg N2FhYjE4ZGQyY2E1Li4xMzc0NzVjMjhlOGYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZWRpYS92 NGwyLWNvcmUvdjRsMi1pb2N0bC5jCj4gKysrIGIvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdjRs Mi1pb2N0bC5jCj4gQEAgLTQzOCwxNSArNDM4LDE0IEBAIHN0YXRpYyB2b2lkIHY0bF9wcmludF9i dWZmZXIoY29uc3Qgdm9pZCAqYXJnLCBib29sIHdyaXRlX29ubHkpCj4gIAljb25zdCBzdHJ1Y3Qg djRsMl90aW1lY29kZSAqdGMgPSAmcC0+dGltZWNvZGU7Cj4gIAljb25zdCBzdHJ1Y3QgdjRsMl9w bGFuZSAqcGxhbmU7Cj4gIAlpbnQgaTsKPiArCS8qIHkyMDM4IHNhZmUgYmVjYXVzZSBvZiBtb25v dG9uaWMgdGltZSAqLwo+ICsJdW5zaWduZWQgaW50IHNlY29uZHMgPSBwLT50aW1lc3RhbXAudHZf c2VjOwo+ICAKPiAtCXByX2NvbnQoIiUwMmxkOiUwMmQ6JTAyZC4lMDhsZCBpbmRleD0lZCwgdHlw ZT0lcywgIgo+ICsJcHJfY29udCgiJTAyZDolMDJkOiUwMmQuJTA4bGQgaW5kZXg9JWQsIHR5cGU9 JXMsICIKPiAgCQkiZmxhZ3M9MHglMDh4LCBmaWVsZD0lcywgc2VxdWVuY2U9JWQsIG1lbW9yeT0l cyIsCj4gLQkJCXAtPnRpbWVzdGFtcC50dl9zZWMgLyAzNjAwLAo+IC0JCQkoaW50KShwLT50aW1l c3RhbXAudHZfc2VjIC8gNjApICUgNjAsCj4gLQkJCShpbnQpKHAtPnRpbWVzdGFtcC50dl9zZWMg JSA2MCksCj4gLQkJCShsb25nKXAtPnRpbWVzdGFtcC50dl91c2VjLAo+IC0JCQlwLT5pbmRleCwK PiAtCQkJcHJ0X25hbWVzKHAtPnR5cGUsIHY0bDJfdHlwZV9uYW1lcyksCj4gKwkJCXNlY29uZHMg LyAzNjAwLCAoc2Vjb25kcyAvIDYwKSAlIDYwLAo+ICsJCQlzZWNvbmRzICUgNjAsIChsb25nKXAt PnRpbWVzdGFtcC50dl91c2VjLAo+ICsJCQlwLT5pbmRleCwgcHJ0X25hbWVzKHAtPnR5cGUsIHY0 bDJfdHlwZV9uYW1lcyksCj4gIAkJCXAtPmZsYWdzLCBwcnRfbmFtZXMocC0+ZmllbGQsIHY0bDJf ZmllbGRfbmFtZXMpLAo+ICAJCQlwLT5zZXF1ZW5jZSwgcHJ0X25hbWVzKHAtPm1lbW9yeSwgdjRs Ml9tZW1vcnlfbmFtZXMpKTsKPiAgCj4gQEAgLTE4NDYsNiArMTg0NSwxMjMgQEAgc3RhdGljIGlu dCB2NGxfcHJlcGFyZV9idWYoY29uc3Qgc3RydWN0IHY0bDJfaW9jdGxfb3BzICpvcHMsCj4gIAly ZXR1cm4gcmV0ID8gcmV0IDogb3BzLT52aWRpb2NfcHJlcGFyZV9idWYoZmlsZSwgZmgsIGIpOwo+ ICB9Cj4gIAo+ICsjaWZuZGVmIENPTkZJR182NEJJVAo+ICtzdGF0aWMgdm9pZCB2NGxfZ2V0X2J1 ZmZlcl90aW1lMzIoc3RydWN0IHY0bDJfYnVmZmVyICp0bywKPiArCQkJCSAgY29uc3Qgc3RydWN0 IHY0bDJfYnVmZmVyX3RpbWUzMiAqZnJvbSkKPiArewo+ICsJdG8tPmluZGV4CQk9IGZyb20tPmlu ZGV4Owo+ICsJdG8tPnR5cGUJCT0gZnJvbS0+dHlwZTsKPiArCXRvLT5ieXRlc3VzZWQJCT0gZnJv bS0+Ynl0ZXN1c2VkOwo+ICsJdG8tPmZsYWdzCQk9IGZyb20tPmZsYWdzOwo+ICsJdG8tPmZpZWxk CQk9IGZyb20tPmZpZWxkOwo+ICsJdG8tPnRpbWVzdGFtcC50dl9zZWMJPSBmcm9tLT50aW1lc3Rh bXAudHZfc2VjOwo+ICsJdG8tPnRpbWVzdGFtcC50dl91c2VjCT0gZnJvbS0+dGltZXN0YW1wLnR2 X3VzZWM7Cj4gKwl0by0+dGltZWNvZGUJCT0gZnJvbS0+dGltZWNvZGU7Cj4gKwl0by0+c2VxdWVu Y2UJCT0gZnJvbS0+c2VxdWVuY2U7Cj4gKwl0by0+bWVtb3J5CQk9IGZyb20tPm1lbW9yeTsKPiAr CXRvLT5tLm9mZnNldAkJPSBmcm9tLT5tLm9mZnNldDsKPiArCXRvLT5sZW5ndGgJCT0gZnJvbS0+ bGVuZ3RoOwo+ICsJdG8tPnJlc2VydmVkMgkJPSBmcm9tLT5yZXNlcnZlZDI7Cj4gKwl0by0+cmVz ZXJ2ZWQJCT0gZnJvbS0+cmVzZXJ2ZWQ7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHY0bF9wdXRf YnVmZmVyX3RpbWUzMihzdHJ1Y3QgdjRsMl9idWZmZXJfdGltZTMyICp0bywKPiArCQkJCSAgY29u c3Qgc3RydWN0IHY0bDJfYnVmZmVyICpmcm9tKQo+ICt7Cj4gKwl0by0+aW5kZXgJCT0gZnJvbS0+ aW5kZXg7Cj4gKwl0by0+dHlwZQkJPSBmcm9tLT50eXBlOwo+ICsJdG8tPmJ5dGVzdXNlZAkJPSBm cm9tLT5ieXRlc3VzZWQ7Cj4gKwl0by0+ZmxhZ3MJCT0gZnJvbS0+ZmxhZ3M7Cj4gKwl0by0+Zmll bGQJCT0gZnJvbS0+ZmllbGQ7Cj4gKwl0by0+dGltZXN0YW1wLnR2X3NlYwk9IGZyb20tPnRpbWVz dGFtcC50dl9zZWM7Cj4gKwl0by0+dGltZXN0YW1wLnR2X3VzZWMJPSBmcm9tLT50aW1lc3RhbXAu dHZfdXNlYzsKPiArCXRvLT50aW1lY29kZQkJPSBmcm9tLT50aW1lY29kZTsKPiArCXRvLT5zZXF1 ZW5jZQkJPSBmcm9tLT5zZXF1ZW5jZTsKPiArCXRvLT5tZW1vcnkJCT0gZnJvbS0+bWVtb3J5Owo+ ICsJdG8tPm0ub2Zmc2V0CQk9IGZyb20tPm0ub2Zmc2V0Owo+ICsJdG8tPmxlbmd0aAkJPSBmcm9t LT5sZW5ndGg7Cj4gKwl0by0+cmVzZXJ2ZWQyCQk9IGZyb20tPnJlc2VydmVkMjsKPiArCXRvLT5y ZXNlcnZlZAkJPSBmcm9tLT5yZXNlcnZlZDsKPiArfQoKSXMgdGhlcmUgYSByZWFzb24gd2h5IHlv dSBkaWRuJ3QgdXNlIG1lbWNweSBsaWtlIHlvdSBkaWQgZm9yIFZJRElPQ19EUUVWRU5UIChwYXRo IDUvOSk/Ckkgd291bGQgcHJlZmVyIHRoYXQgb3ZlciB0aGVzZSBleHBsaWNpdCBhc3NpZ25tZW50 cy4KCj4gKwo+ICtzdGF0aWMgaW50IHY0bF9xdWVyeWJ1Zl90aW1lMzIoY29uc3Qgc3RydWN0IHY0 bDJfaW9jdGxfb3BzICpvcHMsCj4gKwkJCQlzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZmgsIHZv aWQgKmFyZykKPiArewo+ICsJc3RydWN0IHY0bDJfYnVmZmVyIGJ1ZmZlcjsKPiArCWludCByZXQ7 Cj4gKwo+ICsJdjRsX2dldF9idWZmZXJfdGltZTMyKCZidWZmZXIsIGFyZyk7Cj4gKwlyZXQgPSB2 NGxfcXVlcnlidWYob3BzLCBmaWxlLCBmaCwgJmJ1ZmZlcik7Cj4gKwl2NGxfcHV0X2J1ZmZlcl90 aW1lMzIoYXJnLCAmYnVmZmVyKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW50IHY0bF9xYnVmX3RpbWUzMihjb25zdCBzdHJ1Y3QgdjRsMl9pb2N0bF9vcHMgKm9wcywK PiArCQkJCXN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpmaCwgdm9pZCAqYXJnKQo+ICt7Cj4gKwlz dHJ1Y3QgdjRsMl9idWZmZXIgYnVmZmVyOwo+ICsJaW50IHJldDsKPiArCj4gKwl2NGxfZ2V0X2J1 ZmZlcl90aW1lMzIoJmJ1ZmZlciwgYXJnKTsKPiArCXJldCA9IHY0bF9xYnVmKG9wcywgZmlsZSwg ZmgsICZidWZmZXIpOwo+ICsJdjRsX3B1dF9idWZmZXJfdGltZTMyKGFyZywgJmJ1ZmZlcik7Cj4g Kwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCB2NGxfZHFidWZfdGltZTMy KGNvbnN0IHN0cnVjdCB2NGwyX2lvY3RsX29wcyAqb3BzLAo+ICsJCQkJc3RydWN0IGZpbGUgKmZp bGUsIHZvaWQgKmZoLCB2b2lkICphcmcpCj4gK3sKPiArCXN0cnVjdCB2NGwyX2J1ZmZlciBidWZm ZXI7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXY0bF9nZXRfYnVmZmVyX3RpbWUzMigmYnVmZmVyLCBh cmcpOwo+ICsJcmV0ID0gdjRsX2RxYnVmKG9wcywgZmlsZSwgZmgsICZidWZmZXIpOwo+ICsJdjRs X3B1dF9idWZmZXJfdGltZTMyKGFyZywgJmJ1ZmZlcik7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiAr fQo+ICsKPiArc3RhdGljIGludCB2NGxfcHJlcGFyZV9idWZfdGltZTMyKGNvbnN0IHN0cnVjdCB2 NGwyX2lvY3RsX29wcyAqb3BzLAo+ICsJCQkJc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKmZoLCB2 b2lkICphcmcpCj4gK3sKPiArCXN0cnVjdCB2NGwyX2J1ZmZlciBidWZmZXI7Cj4gKwlpbnQgcmV0 Owo+ICsKPiArCXY0bF9nZXRfYnVmZmVyX3RpbWUzMigmYnVmZmVyLCBhcmcpOwo+ICsJcmV0ID0g djRsX3ByZXBhcmVfYnVmKG9wcywgZmlsZSwgZmgsICZidWZmZXIpOwo+ICsKPiArCXJldHVybiBy ZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHY0bF9wcmludF9idWZmZXJfdGltZTMyKGNvbnN0 IHZvaWQgKmFyZywgYm9vbCB3cml0ZV9vbmx5KQo+ICt7Cj4gKwlzdHJ1Y3QgdjRsMl9idWZmZXIg YnVmZmVyOwo+ICsKPiArCXY0bF9nZXRfYnVmZmVyX3RpbWUzMigmYnVmZmVyLCBhcmcpOwo+ICsJ djRsX3ByaW50X2J1ZmZlcigmYnVmZmVyLCB3cml0ZV9vbmx5KTsKPiArfQo+ICsKPiArI2lmZGVm IENPTkZJR19UUkFDRVBPSU5UUwo+ICtzdGF0aWMgdm9pZCB0cmFjZV92NGwyX2RxYnVmX3RpbWUz MihpbnQgbWlub3IsIGNvbnN0IHN0cnVjdCB2NGwyX2J1ZmZlcl90aW1lMzIgKmFyZykKPiArewo+ ICsJc3RydWN0IHY0bDJfYnVmZmVyIGJ1ZmZlcjsKPiArCj4gKwl2NGxfZ2V0X2J1ZmZlcl90aW1l MzIoJmJ1ZmZlciwgYXJnKTsKPiArCXRyYWNlX3Y0bDJfZHFidWYobWlub3IsICZidWZmZXIpOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB0cmFjZV92NGwyX3FidWZfdGltZTMyKGludCBtaW5vciwg Y29uc3Qgc3RydWN0IHY0bDJfYnVmZmVyX3RpbWUzMiAqYXJnKQo+ICt7Cj4gKwlzdHJ1Y3QgdjRs Ml9idWZmZXIgYnVmZmVyOwo+ICsKPiArCXY0bF9nZXRfYnVmZmVyX3RpbWUzMigmYnVmZmVyLCBh cmcpOwo+ICsJdHJhY2VfdjRsMl9xYnVmKG1pbm9yLCAmYnVmZmVyKTsKPiArfQo+ICsjZW5kaWYK PiArI2VuZGlmCj4gKwo+ICBzdGF0aWMgaW50IHY0bF9nX3Bhcm0oY29uc3Qgc3RydWN0IHY0bDJf aW9jdGxfb3BzICpvcHMsCj4gIAkJCQlzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZmgsIHZvaWQg KmFyZykKPiAgewo+IEBAIC0yNDA4LDEyICsyNTI0LDIxIEBAIHN0YXRpYyBzdHJ1Y3QgdjRsMl9p b2N0bF9pbmZvIHY0bDJfaW9jdGxzW10gPSB7Cj4gIAlJT0NUTF9JTkZPX0ZOQyhWSURJT0NfU19G TVQsIHY0bF9zX2ZtdCwgdjRsX3ByaW50X2Zvcm1hdCwgSU5GT19GTF9QUklPKSwKPiAgCUlPQ1RM X0lORk9fRk5DKFZJRElPQ19SRVFCVUZTLCB2NGxfcmVxYnVmcywgdjRsX3ByaW50X3JlcXVlc3Ri dWZmZXJzLCBJTkZPX0ZMX1BSSU8gfCBJTkZPX0ZMX1FVRVVFKSwKPiAgCUlPQ1RMX0lORk9fRk5D KFZJRElPQ19RVUVSWUJVRiwgdjRsX3F1ZXJ5YnVmLCB2NGxfcHJpbnRfYnVmZmVyLCBJTkZPX0ZM X1FVRVVFIHwgSU5GT19GTF9DTEVBUih2NGwyX2J1ZmZlciwgbGVuZ3RoKSksCj4gKyNpZm5kZWYg Q09ORklHXzY0QklUCj4gKwlJT0NUTF9JTkZPX0ZOQyhWSURJT0NfUVVFUllCVUZfVElNRTMyLCB2 NGxfcXVlcnlidWZfdGltZTMyLCB2NGxfcHJpbnRfYnVmZmVyX3RpbWUzMiwgSU5GT19GTF9RVUVV RSB8IElORk9fRkxfQ0xFQVIodjRsMl9idWZmZXIsIGxlbmd0aCkpLAo+ICsjZW5kaWYKClRoaXMg ZG9lc24ndCB3b3JrLiBUaGVzZSBJT0NUTCBtYWNyb3MgdXNlIHRoZSBpb2N0bCBuciBhcyB0aGUg aW5kZXggaW4gdGhlIGFycmF5LiBTaW5jZQpWSURJT0NfUVVFUllCVUYgYW5kIFZJRElPQ19RVUVS WUJVRl9USU1FMzIgaGF2ZSB0aGUgc2FtZSBpbmRleCwgdGhpcyB3aWxsIGZhaWwuCgpJIHRoaW5r IChub3QgMTAwJSBjZXJ0YWluLCB0aGVyZSBtYXkgYmUgYmV0dGVyIHN1Z2dlc3Rpb25zKSB0aGF0 IHRoZSBjb252ZXJzaW9uIGlzIGJlc3QKZG9uZSBpbiB2aWRlb191c2VyY29weSgpOiBqdXN0IGJl Zm9yZSBmdW5jKCkgaXMgY2FsbGVkIGhhdmUgYSBzd2l0Y2ggZm9yIHRoZSBUSU1FMzIKdmFyaWFu dHMsIGNvbnZlcnQgdG8gdGhlIHJlZ3VsYXIgdmFyaWFudCwgY2FsbCBmdW5jKCkgYW5kIGNvbnZl cnQgYmFjay4KCk15IG9ubHkgY29uY2VybiBoZXJlIGlzIHRoYXQgYW4gYWRkaXRpb25hbCB2NGwy X2J1ZmZlciBzdHJ1Y3QgKDY4IGJ5dGVzKSBpcyBuZWVkZWQgb24gdGhlCnN0YWNrLiBJIGRvbid0 IHNlZSBhbnkgd2F5IGFyb3VuZCB0aGF0LCB0aG91Z2guCgo+ICAJSU9DVExfSU5GT19TVEQoVklE SU9DX0dfRkJVRiwgdmlkaW9jX2dfZmJ1ZiwgdjRsX3ByaW50X2ZyYW1lYnVmZmVyLCAwKSwKPiAg CUlPQ1RMX0lORk9fU1REKFZJRElPQ19TX0ZCVUYsIHZpZGlvY19zX2ZidWYsIHY0bF9wcmludF9m cmFtZWJ1ZmZlciwgSU5GT19GTF9QUklPKSwKPiAgCUlPQ1RMX0lORk9fRk5DKFZJRElPQ19PVkVS TEFZLCB2NGxfb3ZlcmxheSwgdjRsX3ByaW50X3UzMiwgSU5GT19GTF9QUklPKSwKPiAgCUlPQ1RM X0lORk9fRk5DKFZJRElPQ19RQlVGLCB2NGxfcWJ1ZiwgdjRsX3ByaW50X2J1ZmZlciwgSU5GT19G TF9RVUVVRSksCj4gKyNpZm5kZWYgQ09ORklHXzY0QklUCj4gKwlJT0NUTF9JTkZPX0ZOQyhWSURJ T0NfUUJVRl9USU1FMzIsIHY0bF9xYnVmX3RpbWUzMiwgdjRsX3ByaW50X2J1ZmZlcl90aW1lMzIs IElORk9fRkxfUVVFVUUpLAo+ICsjZW5kaWYKPiAgCUlPQ1RMX0lORk9fU1REKFZJRElPQ19FWFBC VUYsIHZpZGlvY19leHBidWYsIHY0bF9wcmludF9leHBvcnRidWZmZXIsIElORk9fRkxfUVVFVUUg fCBJTkZPX0ZMX0NMRUFSKHY0bDJfZXhwb3J0YnVmZmVyLCBmbGFncykpLAo+ICAJSU9DVExfSU5G T19GTkMoVklESU9DX0RRQlVGLCB2NGxfZHFidWYsIHY0bF9wcmludF9idWZmZXIsIElORk9fRkxf UVVFVUUpLAo+ICsjaWZuZGVmIENPTkZJR182NEJJVAo+ICsJSU9DVExfSU5GT19GTkMoVklESU9D X0RRQlVGX1RJTUUzMiwgdjRsX2RxYnVmX3RpbWUzMiwgdjRsX3ByaW50X2J1ZmZlcl90aW1lMzIs IElORk9fRkxfUVVFVUUpLAo+ICsjZW5kaWYKPiAgCUlPQ1RMX0lORk9fRk5DKFZJRElPQ19TVFJF QU1PTiwgdjRsX3N0cmVhbW9uLCB2NGxfcHJpbnRfYnVmdHlwZSwgSU5GT19GTF9QUklPIHwgSU5G T19GTF9RVUVVRSksCj4gIAlJT0NUTF9JTkZPX0ZOQyhWSURJT0NfU1RSRUFNT0ZGLCB2NGxfc3Ry ZWFtb2ZmLCB2NGxfcHJpbnRfYnVmdHlwZSwgSU5GT19GTF9QUklPIHwgSU5GT19GTF9RVUVVRSks Cj4gIAlJT0NUTF9JTkZPX0ZOQyhWSURJT0NfR19QQVJNLCB2NGxfZ19wYXJtLCB2NGxfcHJpbnRf c3RyZWFtcGFybSwgSU5GT19GTF9DTEVBUih2NGwyX3N0cmVhbXBhcm0sIHR5cGUpKSwKPiBAQCAt MjQ3OSw2ICsyNjA0LDkgQEAgc3RhdGljIHN0cnVjdCB2NGwyX2lvY3RsX2luZm8gdjRsMl9pb2N0 bHNbXSA9IHsKPiAgCUlPQ1RMX0lORk9fRk5DKFZJRElPQ19VTlNVQlNDUklCRV9FVkVOVCwgdjRs X3Vuc3Vic2NyaWJlX2V2ZW50LCB2NGxfcHJpbnRfZXZlbnRfc3Vic2NyaXB0aW9uLCAwKSwKPiAg CUlPQ1RMX0lORk9fRk5DKFZJRElPQ19DUkVBVEVfQlVGUywgdjRsX2NyZWF0ZV9idWZzLCB2NGxf cHJpbnRfY3JlYXRlX2J1ZmZlcnMsIElORk9fRkxfUFJJTyB8IElORk9fRkxfUVVFVUUpLAo+ICAJ SU9DVExfSU5GT19GTkMoVklESU9DX1BSRVBBUkVfQlVGLCB2NGxfcHJlcGFyZV9idWYsIHY0bF9w cmludF9idWZmZXIsIElORk9fRkxfUVVFVUUpLAo+ICsjaWZuZGVmIENPTkZJR182NEJJVAo+ICsJ SU9DVExfSU5GT19GTkMoVklESU9DX1BSRVBBUkVfQlVGX1RJTUUzMiwgdjRsX3ByZXBhcmVfYnVm X3RpbWUzMiwgdjRsX3ByaW50X2J1ZmZlcl90aW1lMzIsIElORk9fRkxfUVVFVUUpLAo+ICsjZW5k aWYKPiAgCUlPQ1RMX0lORk9fU1REKFZJRElPQ19FTlVNX0RWX1RJTUlOR1MsIHZpZGlvY19lbnVt X2R2X3RpbWluZ3MsIHY0bF9wcmludF9lbnVtX2R2X3RpbWluZ3MsIDApLAo+ICAJSU9DVExfSU5G T19TVEQoVklESU9DX1FVRVJZX0RWX1RJTUlOR1MsIHZpZGlvY19xdWVyeV9kdl90aW1pbmdzLCB2 NGxfcHJpbnRfZHZfdGltaW5ncywgMCksCj4gIAlJT0NUTF9JTkZPX1NURChWSURJT0NfRFZfVElN SU5HU19DQVAsIHZpZGlvY19kdl90aW1pbmdzX2NhcCwgdjRsX3ByaW50X2R2X3RpbWluZ3NfY2Fw LCBJTkZPX0ZMX0NMRUFSKHY0bDJfZHZfdGltaW5nc19jYXAsIHR5cGUpKSwKPiBAQCAtMjYwOCw2 ICsyNzM2LDEyIEBAIGRvbmU6Cj4gIAkJICAgIChjbWQgPT0gVklESU9DX1FCVUYgfHwgY21kID09 IFZJRElPQ19EUUJVRikpCj4gIAkJCXJldHVybiByZXQ7Cj4gIAo+ICsjaWZuZGVmIENPTkZJR182 NEJJVAo+ICsJCWlmICghKGRldl9kZWJ1ZyAmIFY0TDJfREVWX0RFQlVHX1NUUkVBTUlORykgJiYK PiArCQkgICAgKGNtZCA9PSBWSURJT0NfUUJVRl9USU1FMzIgfHwgY21kID09IFZJRElPQ19EUUJV Rl9USU1FMzIpKQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsjZW5kaWYKPiArCj4gIAkJdjRsX3ByaW50 a19pb2N0bCh2aWRlb19kZXZpY2Vfbm9kZV9uYW1lKHZmZCksIGNtZCk7Cj4gIAkJaWYgKHJldCA8 IDApCj4gIAkJCXByX2NvbnQoIjogZXJyb3IgJWxkIiwgcmV0KTsKPiBAQCAtMjYzMCw2ICsyNzY0 LDI2IEBAIHN0YXRpYyBpbnQgY2hlY2tfYXJyYXlfYXJncyh1bnNpZ25lZCBpbnQgY21kLCB2b2lk ICpwYXJnLCBzaXplX3QgKmFycmF5X3NpemUsCj4gIAlpbnQgcmV0ID0gMDsKPiAgCj4gIAlzd2l0 Y2ggKGNtZCkgewo+ICsjaWZuZGVmIENPTkZJR182NEJJVAo+ICsJY2FzZSBWSURJT0NfUFJFUEFS RV9CVUZfVElNRTMyOgo+ICsJY2FzZSBWSURJT0NfUVVFUllCVUZfVElNRTMyOgo+ICsJY2FzZSBW SURJT0NfUUJVRl9USU1FMzI6Cj4gKwljYXNlIFZJRElPQ19EUUJVRl9USU1FMzI6IHsKPiArCQlz dHJ1Y3QgdjRsMl9idWZmZXJfdGltZTMyICpidWYgPSBwYXJnOwo+ICsKPiArCQlpZiAoVjRMMl9U WVBFX0lTX01VTFRJUExBTkFSKGJ1Zi0+dHlwZSkgJiYgYnVmLT5sZW5ndGggPiAwKSB7Cj4gKwkJ CWlmIChidWYtPmxlbmd0aCA+IFZJREVPX01BWF9QTEFORVMpIHsKPiArCQkJCXJldCA9IC1FSU5W QUw7Cj4gKwkJCQlicmVhazsKPiArCQkJfQo+ICsJCQkqdXNlcl9wdHIgPSAodm9pZCBfX3VzZXIg KilidWYtPm0ucGxhbmVzOwo+ICsJCQkqa2VybmVsX3B0ciA9ICh2b2lkICoqKSZidWYtPm0ucGxh bmVzOwo+ICsJCQkqYXJyYXlfc2l6ZSA9IHNpemVvZihzdHJ1Y3QgdjRsMl9wbGFuZSkgKiBidWYt Pmxlbmd0aDsKPiArCQkJcmV0ID0gMTsKPiArCQl9Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKyNlbmRp Zgo+ICAJY2FzZSBWSURJT0NfUFJFUEFSRV9CVUY6Cj4gIAljYXNlIFZJRElPQ19RVUVSWUJVRjoK PiAgCWNhc2UgVklESU9DX1FCVUY6Cj4gQEAgLTI3NzQsNiArMjkyOCwxMiBAQCB2aWRlb191c2Vy Y29weShzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBh cmcsCj4gIAkJCXRyYWNlX3Y0bDJfZHFidWYodmlkZW9fZGV2ZGF0YShmaWxlKS0+bWlub3IsIHBh cmcpOwo+ICAJCWVsc2UgaWYgKGNtZCA9PSBWSURJT0NfUUJVRikKPiAgCQkJdHJhY2VfdjRsMl9x YnVmKHZpZGVvX2RldmRhdGEoZmlsZSktPm1pbm9yLCBwYXJnKTsKPiArI2lmbmRlZiBDT05GSUdf NjRCSVQKPiArCQllbHNlIGlmIChjbWQgPT0gVklESU9DX0RRQlVGX1RJTUUzMikKPiArCQkJdHJh Y2VfdjRsMl9kcWJ1Zl90aW1lMzIodmlkZW9fZGV2ZGF0YShmaWxlKS0+bWlub3IsIHBhcmcpOwo+ ICsJCWVsc2UgaWYgKGNtZCA9PSBWSURJT0NfUUJVRl9USU1FMzIpCj4gKwkJCXRyYWNlX3Y0bDJf cWJ1Zl90aW1lMzIodmlkZW9fZGV2ZGF0YShmaWxlKS0+bWlub3IsIHBhcmcpOwo+ICsjZW5kaWYK PiAgCX0KPiAgCj4gIAlpZiAoaGFzX2FycmF5X2FyZ3MpIHsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVk ZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oIGIvaW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5o Cj4gaW5kZXggNDUwYjMyNDliYTMwLi4wZDM2ODhhOTdhYjggMTAwNjQ0Cj4gLS0tIGEvaW5jbHVk ZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oCj4gKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVv ZGV2Mi5oCj4gQEAgLTgxMSw4ICs4MTEsOCBAQCBzdHJ1Y3QgdjRsMl9wbGFuZSB7Cj4gICAqIHRp bWVfdCwgc28gd2UgaGF2ZSB0byBjb252ZXJ0IGl0IHdoZW4gYWNjZXNzaW5nIHVzZXIgZGF0YS4K PiAgICovCj4gIHN0cnVjdCB2NGwyX3RpbWV2YWwgewo+IC0JbG9uZyB0dl9zZWM7Cj4gLQlsb25n IHR2X3VzZWM7Cj4gKwlfX3M2NCB0dl9zZWM7Cj4gKwlfX3M2NCB0dl91c2VjOwo+ICB9Owo+ICAj ZW5kaWYKPiAgCj4gQEAgLTg3Myw2ICs4NzMsMzIgQEAgc3RydWN0IHY0bDJfYnVmZmVyIHsKPiAg CV9fdTMyCQkJcmVzZXJ2ZWQ7Cj4gIH07Cj4gIAo+ICtzdHJ1Y3QgdjRsMl9idWZmZXJfdGltZTMy IHsKPiArCV9fdTMyCQkJaW5kZXg7Cj4gKwlfX3UzMgkJCXR5cGU7Cj4gKwlfX3UzMgkJCWJ5dGVz dXNlZDsKPiArCV9fdTMyCQkJZmxhZ3M7Cj4gKwlfX3UzMgkJCWZpZWxkOwo+ICsJc3RydWN0IHsK PiArCQlfX3MzMgkJdHZfc2VjOwo+ICsJCV9fczMyCQl0dl91c2VjOwo+ICsJfQkJCXRpbWVzdGFt cDsKPiArCXN0cnVjdCB2NGwyX3RpbWVjb2RlCXRpbWVjb2RlOwo+ICsJX191MzIJCQlzZXF1ZW5j ZTsKPiArCj4gKwkvKiBtZW1vcnkgbG9jYXRpb24gKi8KPiArCV9fdTMyCQkJbWVtb3J5Owo+ICsJ dW5pb24gewo+ICsJCV9fdTMyICAgICAgICAgICBvZmZzZXQ7Cj4gKwkJdW5zaWduZWQgbG9uZyAg IHVzZXJwdHI7Cj4gKwkJc3RydWN0IHY0bDJfcGxhbmUgKnBsYW5lczsKPiArCQlfX3MzMgkJZmQ7 Cj4gKwl9IG07Cj4gKwlfX3UzMgkJCWxlbmd0aDsKPiArCV9fdTMyCQkJcmVzZXJ2ZWQyOwo+ICsJ X191MzIJCQlyZXNlcnZlZDsKPiArfTsKClNob3VsZCB0aGlzIGJlIHBhcnQgb2YgYSBwdWJsaWMg QVBJIGF0IGFsbD8gVXNlcnNwYWNlIHdpbGwgbmV2ZXIgdXNlIHRoaXMgc3RydWN0Cm9yIHRoZSBU SU1FMzIgaW9jdGxzIGluIHRoZSBzb3VyY2UgY29kZSwgcmlnaHQ/IFRoaXMgd291bGQgYmUgbW9y ZSBhcHByb3ByaWF0ZSBmb3IKdjRsMi1pb2N0bC5oLgoKPiArCj4gIC8qICBGbGFncyBmb3IgJ2Zs YWdzJyBmaWVsZCAqLwo+ICAvKiBCdWZmZXIgaXMgbWFwcGVkIChmbGFnKSAqLwo+ICAjZGVmaW5l IFY0TDJfQlVGX0ZMQUdfTUFQUEVECQkJMHgwMDAwMDAwMQo+IEBAIC0yMjE2LDEyICsyMjQyLDE1 IEBAIHN0cnVjdCB2NGwyX2NyZWF0ZV9idWZmZXJzIHsKPiAgI2RlZmluZSBWSURJT0NfU19GTVQJ CV9JT1dSKCdWJywgIDUsIHN0cnVjdCB2NGwyX2Zvcm1hdCkKPiAgI2RlZmluZSBWSURJT0NfUkVR QlVGUwkJX0lPV1IoJ1YnLCAgOCwgc3RydWN0IHY0bDJfcmVxdWVzdGJ1ZmZlcnMpCj4gICNkZWZp bmUgVklESU9DX1FVRVJZQlVGCQlfSU9XUignVicsICA5LCBzdHJ1Y3QgdjRsMl9idWZmZXIpCj4g KyNkZWZpbmUgVklESU9DX1FVRVJZQlVGX1RJTUUzMglfSU9XUignVicsICA5LCBzdHJ1Y3QgdjRs Ml9idWZmZXJfdGltZTMyKQo+ICAjZGVmaW5lIFZJRElPQ19HX0ZCVUYJCSBfSU9SKCdWJywgMTAs IHN0cnVjdCB2NGwyX2ZyYW1lYnVmZmVyKQo+ICAjZGVmaW5lIFZJRElPQ19TX0ZCVUYJCSBfSU9X KCdWJywgMTEsIHN0cnVjdCB2NGwyX2ZyYW1lYnVmZmVyKQo+ICAjZGVmaW5lIFZJRElPQ19PVkVS TEFZCQkgX0lPVygnVicsIDE0LCBpbnQpCj4gICNkZWZpbmUgVklESU9DX1FCVUYJCV9JT1dSKCdW JywgMTUsIHN0cnVjdCB2NGwyX2J1ZmZlcikKPiArI2RlZmluZSBWSURJT0NfUUJVRl9USU1FMzIJ X0lPV1IoJ1YnLCAxNSwgc3RydWN0IHY0bDJfYnVmZmVyX3RpbWUzMikKPiAgI2RlZmluZSBWSURJ T0NfRVhQQlVGCQlfSU9XUignVicsIDE2LCBzdHJ1Y3QgdjRsMl9leHBvcnRidWZmZXIpCj4gICNk ZWZpbmUgVklESU9DX0RRQlVGCQlfSU9XUignVicsIDE3LCBzdHJ1Y3QgdjRsMl9idWZmZXIpCj4g KyNkZWZpbmUgVklESU9DX0RRQlVGX1RJTUUzMglfSU9XUignVicsIDE3LCBzdHJ1Y3QgdjRsMl9i dWZmZXJfdGltZTMyKQo+ICAjZGVmaW5lIFZJRElPQ19TVFJFQU1PTgkJIF9JT1coJ1YnLCAxOCwg aW50KQo+ICAjZGVmaW5lIFZJRElPQ19TVFJFQU1PRkYJIF9JT1coJ1YnLCAxOSwgaW50KQo+ICAj ZGVmaW5lIFZJRElPQ19HX1BBUk0JCV9JT1dSKCdWJywgMjEsIHN0cnVjdCB2NGwyX3N0cmVhbXBh cm0pCj4gQEAgLTIyOTIsNiArMjMyMSw3IEBAIHN0cnVjdCB2NGwyX2NyZWF0ZV9idWZmZXJzIHsK PiAgICAgdmVyc2lvbnMgKi8KPiAgI2RlZmluZSBWSURJT0NfQ1JFQVRFX0JVRlMJX0lPV1IoJ1Yn LCA5Miwgc3RydWN0IHY0bDJfY3JlYXRlX2J1ZmZlcnMpCj4gICNkZWZpbmUgVklESU9DX1BSRVBB UkVfQlVGCV9JT1dSKCdWJywgOTMsIHN0cnVjdCB2NGwyX2J1ZmZlcikKPiArI2RlZmluZSBWSURJ T0NfUFJFUEFSRV9CVUZfVElNRTMyIF9JT1dSKCdWJywgOTMsIHN0cnVjdCB2NGwyX2J1ZmZlcl90 aW1lMzIpCj4gIAo+ICAvKiBFeHBlcmltZW50YWwgc2VsZWN0aW9uIEFQSSAqLwo+ICAjZGVmaW5l IFZJRElPQ19HX1NFTEVDVElPTglfSU9XUignVicsIDk0LCBzdHJ1Y3QgdjRsMl9zZWxlY3Rpb24p Cj4gCgpSZWdhcmRzLAoKCUhhbnMKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KWTIwMzggbWFpbGluZyBsaXN0ClkyMDM4QGxpc3RzLmxpbmFyby5vcmcKaHR0 cHM6Ly9saXN0cy5saW5hcm8ub3JnL21haWxtYW4vbGlzdGluZm8veTIwMzgK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from lb3-smtp-cloud2.xs4all.net ([194.109.24.29]:52309 "EHLO lb3-smtp-cloud2.xs4all.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752307AbbIRHUJ (ORCPT ); Fri, 18 Sep 2015 03:20:09 -0400 Message-ID: <55FBBAD5.4010002@xs4all.nl> Date: Fri, 18 Sep 2015 09:18:45 +0200 From: Hans Verkuil MIME-Version: 1.0 To: Arnd Bergmann , linux-media@vger.kernel.org CC: linux-kernel@vger.kernel.org, y2038@lists.linaro.org, Mauro Carvalho Chehab , linux-api@vger.kernel.org, linux-samsung-soc@vger.kernel.org Subject: Re: [PATCH v2 8/9] [media] handle 64-bit time_t in v4l2_buffer References: <1442524780-781677-1-git-send-email-arnd@arndb.de> <1442524780-781677-9-git-send-email-arnd@arndb.de> In-Reply-To: <1442524780-781677-9-git-send-email-arnd@arndb.de> Content-Type: text/plain; charset=windows-1252 Content-Transfer-Encoding: 7bit Sender: linux-media-owner@vger.kernel.org List-ID: Hi Arnd, Thanks once again for working on this! Unfortunately, this approach won't work, see my comments below. BTW, I would expect to see compile errors when compiling for 32 bit. Did you try that? On 09/17/2015 11:19 PM, Arnd Bergmann wrote: > This is the final change to enable user space with 64-bit time_t > in the core v4l2 code. > > Four ioctls are affected here: VIDIOC_QUERYBUF, VIDIOC_QBUF, > VIDIOC_DQBUF, and VIDIOC_PREPARE_BUF. All of them pass a > struct v4l2_buffer, which can either contain a 32-bit time_t > or a 64-bit time on 32-bit architectures. > > In this patch, we redefine the in-kernel version of this structure > to use the 64-bit __s64 type through the use of v4l2_timeval. > This means the normal ioctl handling now assumes 64-bit time_t > and so we have to add support for 32-bit time_t in new handlers. > > This is somewhat similar to the 32-bit compat handling on 64-bit > architectures, but those also have to modify other fields of > the structure. For now, I leave that compat code alone, as it > handles the normal case (32-bit compat_time_t) correctly, this > has to be done as a follow-up. > > Signed-off-by: Arnd Bergmann > --- > drivers/media/v4l2-core/v4l2-ioctl.c | 174 +++++++++++++++++++++++++++++++++-- > include/uapi/linux/videodev2.h | 34 ++++++- > 2 files changed, 199 insertions(+), 9 deletions(-) > > diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c > index 7aab18dd2ca5..137475c28e8f 100644 > --- a/drivers/media/v4l2-core/v4l2-ioctl.c > +++ b/drivers/media/v4l2-core/v4l2-ioctl.c > @@ -438,15 +438,14 @@ static void v4l_print_buffer(const void *arg, bool write_only) > const struct v4l2_timecode *tc = &p->timecode; > const struct v4l2_plane *plane; > int i; > + /* y2038 safe because of monotonic time */ > + unsigned int seconds = p->timestamp.tv_sec; > > - pr_cont("%02ld:%02d:%02d.%08ld index=%d, type=%s, " > + pr_cont("%02d:%02d:%02d.%08ld index=%d, type=%s, " > "flags=0x%08x, field=%s, sequence=%d, memory=%s", > - p->timestamp.tv_sec / 3600, > - (int)(p->timestamp.tv_sec / 60) % 60, > - (int)(p->timestamp.tv_sec % 60), > - (long)p->timestamp.tv_usec, > - p->index, > - prt_names(p->type, v4l2_type_names), > + seconds / 3600, (seconds / 60) % 60, > + seconds % 60, (long)p->timestamp.tv_usec, > + p->index, prt_names(p->type, v4l2_type_names), > p->flags, prt_names(p->field, v4l2_field_names), > p->sequence, prt_names(p->memory, v4l2_memory_names)); > > @@ -1846,6 +1845,123 @@ static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops, > return ret ? ret : ops->vidioc_prepare_buf(file, fh, b); > } > > +#ifndef CONFIG_64BIT > +static void v4l_get_buffer_time32(struct v4l2_buffer *to, > + const struct v4l2_buffer_time32 *from) > +{ > + to->index = from->index; > + to->type = from->type; > + to->bytesused = from->bytesused; > + to->flags = from->flags; > + to->field = from->field; > + to->timestamp.tv_sec = from->timestamp.tv_sec; > + to->timestamp.tv_usec = from->timestamp.tv_usec; > + to->timecode = from->timecode; > + to->sequence = from->sequence; > + to->memory = from->memory; > + to->m.offset = from->m.offset; > + to->length = from->length; > + to->reserved2 = from->reserved2; > + to->reserved = from->reserved; > +} > + > +static void v4l_put_buffer_time32(struct v4l2_buffer_time32 *to, > + const struct v4l2_buffer *from) > +{ > + to->index = from->index; > + to->type = from->type; > + to->bytesused = from->bytesused; > + to->flags = from->flags; > + to->field = from->field; > + to->timestamp.tv_sec = from->timestamp.tv_sec; > + to->timestamp.tv_usec = from->timestamp.tv_usec; > + to->timecode = from->timecode; > + to->sequence = from->sequence; > + to->memory = from->memory; > + to->m.offset = from->m.offset; > + to->length = from->length; > + to->reserved2 = from->reserved2; > + to->reserved = from->reserved; > +} Is there a reason why you didn't use memcpy like you did for VIDIOC_DQEVENT (path 5/9)? I would prefer that over these explicit assignments. > + > +static int v4l_querybuf_time32(const struct v4l2_ioctl_ops *ops, > + struct file *file, void *fh, void *arg) > +{ > + struct v4l2_buffer buffer; > + int ret; > + > + v4l_get_buffer_time32(&buffer, arg); > + ret = v4l_querybuf(ops, file, fh, &buffer); > + v4l_put_buffer_time32(arg, &buffer); > + > + return ret; > +} > + > +static int v4l_qbuf_time32(const struct v4l2_ioctl_ops *ops, > + struct file *file, void *fh, void *arg) > +{ > + struct v4l2_buffer buffer; > + int ret; > + > + v4l_get_buffer_time32(&buffer, arg); > + ret = v4l_qbuf(ops, file, fh, &buffer); > + v4l_put_buffer_time32(arg, &buffer); > + > + return ret; > +} > + > +static int v4l_dqbuf_time32(const struct v4l2_ioctl_ops *ops, > + struct file *file, void *fh, void *arg) > +{ > + struct v4l2_buffer buffer; > + int ret; > + > + v4l_get_buffer_time32(&buffer, arg); > + ret = v4l_dqbuf(ops, file, fh, &buffer); > + v4l_put_buffer_time32(arg, &buffer); > + > + return ret; > +} > + > +static int v4l_prepare_buf_time32(const struct v4l2_ioctl_ops *ops, > + struct file *file, void *fh, void *arg) > +{ > + struct v4l2_buffer buffer; > + int ret; > + > + v4l_get_buffer_time32(&buffer, arg); > + ret = v4l_prepare_buf(ops, file, fh, &buffer); > + > + return ret; > +} > + > +static void v4l_print_buffer_time32(const void *arg, bool write_only) > +{ > + struct v4l2_buffer buffer; > + > + v4l_get_buffer_time32(&buffer, arg); > + v4l_print_buffer(&buffer, write_only); > +} > + > +#ifdef CONFIG_TRACEPOINTS > +static void trace_v4l2_dqbuf_time32(int minor, const struct v4l2_buffer_time32 *arg) > +{ > + struct v4l2_buffer buffer; > + > + v4l_get_buffer_time32(&buffer, arg); > + trace_v4l2_dqbuf(minor, &buffer); > +} > + > +static void trace_v4l2_qbuf_time32(int minor, const struct v4l2_buffer_time32 *arg) > +{ > + struct v4l2_buffer buffer; > + > + v4l_get_buffer_time32(&buffer, arg); > + trace_v4l2_qbuf(minor, &buffer); > +} > +#endif > +#endif > + > static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, > struct file *file, void *fh, void *arg) > { > @@ -2408,12 +2524,21 @@ static struct v4l2_ioctl_info v4l2_ioctls[] = { > IOCTL_INFO_FNC(VIDIOC_S_FMT, v4l_s_fmt, v4l_print_format, INFO_FL_PRIO), > IOCTL_INFO_FNC(VIDIOC_REQBUFS, v4l_reqbufs, v4l_print_requestbuffers, INFO_FL_PRIO | INFO_FL_QUEUE), > IOCTL_INFO_FNC(VIDIOC_QUERYBUF, v4l_querybuf, v4l_print_buffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)), > +#ifndef CONFIG_64BIT > + IOCTL_INFO_FNC(VIDIOC_QUERYBUF_TIME32, v4l_querybuf_time32, v4l_print_buffer_time32, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)), > +#endif This doesn't work. These IOCTL macros use the ioctl nr as the index in the array. Since VIDIOC_QUERYBUF and VIDIOC_QUERYBUF_TIME32 have the same index, this will fail. I think (not 100% certain, there may be better suggestions) that the conversion is best done in video_usercopy(): just before func() is called have a switch for the TIME32 variants, convert to the regular variant, call func() and convert back. My only concern here is that an additional v4l2_buffer struct (68 bytes) is needed on the stack. I don't see any way around that, though. > IOCTL_INFO_STD(VIDIOC_G_FBUF, vidioc_g_fbuf, v4l_print_framebuffer, 0), > IOCTL_INFO_STD(VIDIOC_S_FBUF, vidioc_s_fbuf, v4l_print_framebuffer, INFO_FL_PRIO), > IOCTL_INFO_FNC(VIDIOC_OVERLAY, v4l_overlay, v4l_print_u32, INFO_FL_PRIO), > IOCTL_INFO_FNC(VIDIOC_QBUF, v4l_qbuf, v4l_print_buffer, INFO_FL_QUEUE), > +#ifndef CONFIG_64BIT > + IOCTL_INFO_FNC(VIDIOC_QBUF_TIME32, v4l_qbuf_time32, v4l_print_buffer_time32, INFO_FL_QUEUE), > +#endif > IOCTL_INFO_STD(VIDIOC_EXPBUF, vidioc_expbuf, v4l_print_exportbuffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_exportbuffer, flags)), > IOCTL_INFO_FNC(VIDIOC_DQBUF, v4l_dqbuf, v4l_print_buffer, INFO_FL_QUEUE), > +#ifndef CONFIG_64BIT > + IOCTL_INFO_FNC(VIDIOC_DQBUF_TIME32, v4l_dqbuf_time32, v4l_print_buffer_time32, INFO_FL_QUEUE), > +#endif > IOCTL_INFO_FNC(VIDIOC_STREAMON, v4l_streamon, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE), > IOCTL_INFO_FNC(VIDIOC_STREAMOFF, v4l_streamoff, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE), > IOCTL_INFO_FNC(VIDIOC_G_PARM, v4l_g_parm, v4l_print_streamparm, INFO_FL_CLEAR(v4l2_streamparm, type)), > @@ -2479,6 +2604,9 @@ static struct v4l2_ioctl_info v4l2_ioctls[] = { > IOCTL_INFO_FNC(VIDIOC_UNSUBSCRIBE_EVENT, v4l_unsubscribe_event, v4l_print_event_subscription, 0), > IOCTL_INFO_FNC(VIDIOC_CREATE_BUFS, v4l_create_bufs, v4l_print_create_buffers, INFO_FL_PRIO | INFO_FL_QUEUE), > IOCTL_INFO_FNC(VIDIOC_PREPARE_BUF, v4l_prepare_buf, v4l_print_buffer, INFO_FL_QUEUE), > +#ifndef CONFIG_64BIT > + IOCTL_INFO_FNC(VIDIOC_PREPARE_BUF_TIME32, v4l_prepare_buf_time32, v4l_print_buffer_time32, INFO_FL_QUEUE), > +#endif > IOCTL_INFO_STD(VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings, v4l_print_enum_dv_timings, 0), > IOCTL_INFO_STD(VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings, v4l_print_dv_timings, 0), > IOCTL_INFO_STD(VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap, v4l_print_dv_timings_cap, INFO_FL_CLEAR(v4l2_dv_timings_cap, type)), > @@ -2608,6 +2736,12 @@ done: > (cmd == VIDIOC_QBUF || cmd == VIDIOC_DQBUF)) > return ret; > > +#ifndef CONFIG_64BIT > + if (!(dev_debug & V4L2_DEV_DEBUG_STREAMING) && > + (cmd == VIDIOC_QBUF_TIME32 || cmd == VIDIOC_DQBUF_TIME32)) > + return ret; > +#endif > + > v4l_printk_ioctl(video_device_node_name(vfd), cmd); > if (ret < 0) > pr_cont(": error %ld", ret); > @@ -2630,6 +2764,26 @@ static int check_array_args(unsigned int cmd, void *parg, size_t *array_size, > int ret = 0; > > switch (cmd) { > +#ifndef CONFIG_64BIT > + case VIDIOC_PREPARE_BUF_TIME32: > + case VIDIOC_QUERYBUF_TIME32: > + case VIDIOC_QBUF_TIME32: > + case VIDIOC_DQBUF_TIME32: { > + struct v4l2_buffer_time32 *buf = parg; > + > + if (V4L2_TYPE_IS_MULTIPLANAR(buf->type) && buf->length > 0) { > + if (buf->length > VIDEO_MAX_PLANES) { > + ret = -EINVAL; > + break; > + } > + *user_ptr = (void __user *)buf->m.planes; > + *kernel_ptr = (void **)&buf->m.planes; > + *array_size = sizeof(struct v4l2_plane) * buf->length; > + ret = 1; > + } > + break; > + } > +#endif > case VIDIOC_PREPARE_BUF: > case VIDIOC_QUERYBUF: > case VIDIOC_QBUF: > @@ -2774,6 +2928,12 @@ video_usercopy(struct file *file, unsigned int cmd, unsigned long arg, > trace_v4l2_dqbuf(video_devdata(file)->minor, parg); > else if (cmd == VIDIOC_QBUF) > trace_v4l2_qbuf(video_devdata(file)->minor, parg); > +#ifndef CONFIG_64BIT > + else if (cmd == VIDIOC_DQBUF_TIME32) > + trace_v4l2_dqbuf_time32(video_devdata(file)->minor, parg); > + else if (cmd == VIDIOC_QBUF_TIME32) > + trace_v4l2_qbuf_time32(video_devdata(file)->minor, parg); > +#endif > } > > if (has_array_args) { > diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h > index 450b3249ba30..0d3688a97ab8 100644 > --- a/include/uapi/linux/videodev2.h > +++ b/include/uapi/linux/videodev2.h > @@ -811,8 +811,8 @@ struct v4l2_plane { > * time_t, so we have to convert it when accessing user data. > */ > struct v4l2_timeval { > - long tv_sec; > - long tv_usec; > + __s64 tv_sec; > + __s64 tv_usec; > }; > #endif > > @@ -873,6 +873,32 @@ struct v4l2_buffer { > __u32 reserved; > }; > > +struct v4l2_buffer_time32 { > + __u32 index; > + __u32 type; > + __u32 bytesused; > + __u32 flags; > + __u32 field; > + struct { > + __s32 tv_sec; > + __s32 tv_usec; > + } timestamp; > + struct v4l2_timecode timecode; > + __u32 sequence; > + > + /* memory location */ > + __u32 memory; > + union { > + __u32 offset; > + unsigned long userptr; > + struct v4l2_plane *planes; > + __s32 fd; > + } m; > + __u32 length; > + __u32 reserved2; > + __u32 reserved; > +}; Should this be part of a public API at all? Userspace will never use this struct or the TIME32 ioctls in the source code, right? This would be more appropriate for v4l2-ioctl.h. > + > /* Flags for 'flags' field */ > /* Buffer is mapped (flag) */ > #define V4L2_BUF_FLAG_MAPPED 0x00000001 > @@ -2216,12 +2242,15 @@ struct v4l2_create_buffers { > #define VIDIOC_S_FMT _IOWR('V', 5, struct v4l2_format) > #define VIDIOC_REQBUFS _IOWR('V', 8, struct v4l2_requestbuffers) > #define VIDIOC_QUERYBUF _IOWR('V', 9, struct v4l2_buffer) > +#define VIDIOC_QUERYBUF_TIME32 _IOWR('V', 9, struct v4l2_buffer_time32) > #define VIDIOC_G_FBUF _IOR('V', 10, struct v4l2_framebuffer) > #define VIDIOC_S_FBUF _IOW('V', 11, struct v4l2_framebuffer) > #define VIDIOC_OVERLAY _IOW('V', 14, int) > #define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) > +#define VIDIOC_QBUF_TIME32 _IOWR('V', 15, struct v4l2_buffer_time32) > #define VIDIOC_EXPBUF _IOWR('V', 16, struct v4l2_exportbuffer) > #define VIDIOC_DQBUF _IOWR('V', 17, struct v4l2_buffer) > +#define VIDIOC_DQBUF_TIME32 _IOWR('V', 17, struct v4l2_buffer_time32) > #define VIDIOC_STREAMON _IOW('V', 18, int) > #define VIDIOC_STREAMOFF _IOW('V', 19, int) > #define VIDIOC_G_PARM _IOWR('V', 21, struct v4l2_streamparm) > @@ -2292,6 +2321,7 @@ struct v4l2_create_buffers { > versions */ > #define VIDIOC_CREATE_BUFS _IOWR('V', 92, struct v4l2_create_buffers) > #define VIDIOC_PREPARE_BUF _IOWR('V', 93, struct v4l2_buffer) > +#define VIDIOC_PREPARE_BUF_TIME32 _IOWR('V', 93, struct v4l2_buffer_time32) > > /* Experimental selection API */ > #define VIDIOC_G_SELECTION _IOWR('V', 94, struct v4l2_selection) > Regards, Hans